"""
Plugin for making an asset library of all  blender file found in a folder
"""


from asset_library.adapters.adapter import AssetLibraryAdapter
from asset_library.common.template import Template
from asset_library.common.file_utils import install_module

import bpy
from bpy.props import (StringProperty, IntProperty, BoolProperty)
import re
from pathlib import Path
from itertools import groupby
import uuid
import os
import shutil
import json
import urllib3
import traceback
import time


class KitsuLibrary(AssetLibraryAdapter):

    name = "Kitsu"
    template_name : StringProperty()
    template_file : StringProperty()

    url: StringProperty()
    login: StringProperty()
    password: StringProperty(subtype='PASSWORD')
    project_name: StringProperty()
    
    def connect(self, url=None, login=None, password=None):
        '''Connect to kitsu api using provided url, login and password'''

        gazu = install_module('gazu')
        urllib3.disable_warnings()

        if not self.url:
            print(f'Kitsu Url: {self.url} is empty')
            return

        url = self.url
        if not url.endswith('/api'):
            url += '/api'

        print(f'Info: Setting Host for kitsu {url}')
        gazu.client.set_host(url)

        if not gazu.client.host_is_up():
            print('Error: Kitsu Host is down')

        try:
            print(f'Info: Log in to kitsu as {self.login}')
            res = gazu.log_in(self.login, self.password)
            print(f'Info: Sucessfully login to Kitsu as {res["user"]["full_name"]}')
            return res['user']
        except Exception as e:
            print(f'Error: {traceback.format_exc()}')

    def get_asset_path(self, name, catalog, directory=None):
        directory = directory or self.source_directory
        return Path(directory, self.get_asset_relative_path(name, catalog))

    def get_asset_description(self, data, path):
        
        modified = time.time_ns()
        catalog = data['entity_type_name']
        asset_path = Path(path)
        asset_name = self.norm_file_name(data['name'])

        asset_description = dict(
            filepath=asset_path.as_posix(),
            modified=modified,
            library_id=self.library.id,
            assets=[dict(
                catalog=catalog,
                metadata=data.get('data', {}),
                description=data['description'],
                tags=[],
                type=self.data_type,
                image=str(self.template_image.format(name=asset_name)),
                video=str(self.template_video.format(name=asset_name)),
                name=data['name'])
            ]
        )
        
        return asset_description

    # def bundle(self, cache_diff=None):
    #     """Group all asset in one or multiple blends for the asset browser"""

    #     return super().bundle(cache_diff=cache_diff)

    def get_preview(self, asset_data):

        name = asset_data['name']
        preview = (f / template_image.format(name=name)).resolve()
        if not preview.exists():
            preview_blend_file(f, preview)
        
        return preview

        
    def fetch(self):
        """Gather in a list all assets found in the folder"""

        print(f'Fetch Assets for {self.library.name}')

        gazu = install_module('gazu')
        self.connect()

        template_file = Template(self.template_file)
        template_name = Template(self.template_name)

        project = gazu.client.fetch_first('projects', {'name': self.project_name})
        entity_types = gazu.client.fetch_all('entity-types')
        entity_types_ids = {e['id']: e['name'] for e in entity_types}

        asset_descriptions = []
        for asset_data in gazu.asset.all_assets_for_project(project)[:10]:
            asset_data['entity_type_name'] = entity_types_ids[asset_data.pop('entity_type_id')]
            asset_name = asset_data['name']

            asset_field_data = dict(name=asset_name, type=asset_data['entity_type_name'])

            try:
                asset_field_data.update(template_name.parse(asset_name))
            except Exception:
                print(f'Warning: Could not parse {asset_name} with template {template_name}')

            asset_path = template_file.find(asset_field_data)
            if not asset_path:
                print(f'Warning: Could not find file for {template_file.format(asset_field_data)}')
                continue

            #print(asset_path)

            asset_descriptions.append(self.get_asset_description(asset_data, asset_path))

            #asset = load_datablocks(asset_path, data_type='collections', names=asset_data['name'], link=True)
            #if not asset:
            #    print(f"Asset {asset_name} not found in {asset_path}")


            #asset_description = self.get_asset_description(asset)

            #asset_descriptions.append(asset_description)

        #print(assets)
        # for k, v in assets[0].items():
        #     print(f'- {k} {v}')

        #print('+++++++++++++')
        #print(asset_descriptions)

        return asset_descriptions