import argparse
import sys
import json
from pathlib import Path
import bpy
import re
import uuid
from itertools import groupby

from asset_library.constants import ASSETLIB_FILENAME, MODULE_DIR
from asset_library.common.bl_utils import thumbnail_blend_file
from asset_library.common.functions import command


@command
def bundle_library(
    source_directory,
    bundle_directory,
    template_info,
    thumbnail_template,
    template=None,
    data_file=None,
):

    field_pattern = r"{(\w+)}"
    asset_data_path = Path(bundle_directory) / ASSETLIB_FILENAME

    glob_pattern = re.sub(field_pattern, "*", template)
    re_pattern = re.sub(field_pattern, r"([\\w -_.]+)", template)
    re_pattern = re_pattern.replace("?", ".")

    field_names = re.findall(field_pattern, template)

    asset_file_datas = []
    for f in sorted(Path(source_directory).glob(glob_pattern)):
        rel_path = f.relative_to(source_directory).as_posix()

        field_values = re.findall(re_pattern, rel_path)[0]
        field_data = {k: v for k, v in zip(field_names, field_values)}

        name = field_data.get("name", f.stem)
        thumbnail = (f / thumbnail_template.format(name=name)).resolve()
        asset_data = (f / template_info.format(name=name)).resolve()

        catalogs = sorted(
            [v for k, v in sorted(field_data.items()) if re.findall("cat[0-9]+", k)]
        )
        catalogs = [c.replace("_", " ").title() for c in catalogs]

        if not thumbnail.exists():
            thumbnail_blend_file(f, thumbnail)

        asset_data = {
            "catalog": "/".join(catalogs),
            "preview": thumbnail.as_posix(),  #'./' + bpy.path.relpath(str(thumbnail), start=str(f))[2:],
            "filepath": f.as_posix(),  #'./' + bpy.path.relpath(str(f), start=str(asset_data_path))[2:],
            "name": name,
            "tags": [],
            "metadata": {"filepath": f.as_posix()},
        }

        asset_file_datas.append(asset_data)

    # Write json data file to store all asset found
    print(f"Writing asset data file to, {asset_data_path}")
    asset_data_path.write_text(json.dumps(asset_file_datas, indent=4))

    # script = MODULE_DIR / 'common' / 'bundle_blend.py'
    # cmd = [bpy.app.binary_path, '--python', str(script), '--', '--filepath', str(filepath)]
    # print(cmd)
    # subprocess.call(cmd)


@command
def bundle_blend(filepath, depth=0):
    # print('Bundle Blend...')
    filepath = Path(filepath)

    # asset_data_path = get_asset_datas_file(filepath)

    asset_data_path = filepath / ASSETLIB_FILENAME
    blend_name = filepath.name.replace(" ", "_").lower()
    blend_path = (filepath / blend_name).with_suffix(".blend")

    if not asset_data_path.exists():
        raise Exception(f"The file {asset_data_path} not exist")

    catalog_path = get_catalog_path(filepath)
    catalog_data = read_catalog(catalog_path)

    asset_file_data = json.loads(asset_data_path.read_text())
    # asset_file_data = {i['catalog']:i for i in asset_file_data}

    if depth == 0:
        groups = [asset_file_data]
    else:
        asset_file_data.sort(key=lambda x: x["catalog"].split("/")[:depth])
        groups = groupby(asset_file_data, key=lambda x: x["catalog"].split("/")[:depth])

    # progress = 0
    total_assets = len(asset_file_data)

    i = 0
    for sub_path, asset_datas in groups:
        bpy.ops.wm.read_homefile(use_empty=True)

        for asset_data in asset_datas:
            blend_name = sub_path[-1].replace(" ", "_").lower()
            blend_path = Path(filepath, *sub_path, blend_name).with_suffix(".blend")

            if i % int(total_assets / 100) == 0:
                print(f"Progress: {int(i / total_assets * 100)}")

            col = bpy.data.collections.new(name=asset_data["name"])

            # Seems slow
            # bpy.context.scene.collection.children.link(col)
            col.asset_mark()

            with bpy.context.temp_override(id=col):
                bpy.ops.ed.lib_id_load_custom_preview(filepath=asset_data["preview"])

            col.asset_data.description = asset_data.get("description", "")

            catalog_name = asset_data["catalog"]
            catalog = catalog_data.get(catalog_name)
            if not catalog:
                catalog = {"id": str(uuid.uuid4()), "name": catalog_name}
                catalog_data[catalog_name] = catalog

            col.asset_data.catalog_id = catalog["id"]

            for k, v in asset_data.get("metadata", {}).items():
                col.asset_data[k] = v

            i += 1

        print(f"Saving Blend to {blend_path}")

        blend_path.mkdir(exist_ok=True, parents=True)
        bpy.ops.wm.save_as_mainfile(filepath=str(blend_path), compress=True)

    write_catalog(catalog_path, catalog_data)

    bpy.ops.wm.quit_blender()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="bundle_blend",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )

    parser.add_argument("--source-path")
    parser.add_argument("--bundle-path")
    parser.add_argument("--asset-data-template")
    parser.add_argument("--thumbnail-template")
    parser.add_argument("--template", default=None)
    parser.add_argument("--data-file", default=None)
    parser.add_argument("--depth", default=0, type=int)

    if "--" in sys.argv:
        index = sys.argv.index("--")
        sys.argv = [sys.argv[index - 1], *sys.argv[index + 1 :]]

    args = parser.parse_args()

    bundle_library(
        source_directory=args.source_directory,
        bundle_directory=args.bundle_directory,
        template_info=args.template_info,
        thumbnail_template=args.thumbnail_template,
        template=args.template,
        data_file=args.data_file,
    )

    bundle_blend(filepath=args.bundle_directory, depth=args.depth)