import os
import gazu

from kabaret import flow
from kabaret.flow_contextual_dict import ContextualView, get_contextual_dict

from .departments import Department
from .maputils import ItemMap, CreateItemAction, ClearMapAction
from .lib import AssetDependency, DropAssetAction#, KitsuSettingsView
from .kitsu import KitsuSequence, KitsuShot, UpdateItemsKitsuSettings


class Casting(flow.Map):

    ICON = ('icons.flow', 'casting')

    drag_assets = flow.Child(DropAssetAction)

    @classmethod
    def mapped_type(cls):
        return AssetDependency

    def columns(self):
        return ["Name", "Description"]

    def row(self, item):
        _, row = super(Casting, self).row(item)

        return item.get().oid(), row

    def _fill_row_cells(self, row, item):
        asset = item.get()
        row["Name"] = asset.id.get()
        row["Description"] = asset.description.get()


class DisplayKitsuSettings(flow.Action):

    _map = flow.Parent()

    def needs_dialog(self):
        return False

    def allow_context(self, context):
        return context and context.endswith('.inline')

    def run(self, button):
        displayed = self._map._display_kitsu_settings.get()
        self._map._display_kitsu_settings.set(not displayed)
        self._map.touch()


class ShotDepartments(flow.Object):

    layout = flow.Child(Department).ui(expanded=True)
    animation = flow.Child(Department).ui(expanded=True)
    compositing = flow.Child(Department).ui(expanded=True)


class Shot(KitsuShot):

    ICON = ('icons.flow', 'shot')

    _sequence = flow.Parent(2)

    settings = flow.Child(ContextualView).ui(hidden=True)
    # casting = flow.Child(Casting)

    description = flow.Param('')
    departments = flow.Child(ShotDepartments).ui(expanded=True)

    def get_default_contextual_edits(self, context_name):
        if context_name == 'settings':
            default_settings = get_contextual_dict(self._sequence, context_name)
            path = default_settings.get('path', 'UNKNOWN_PATH')

            return dict(
                path=os.path.join(path, self.name()),
                shot=self.name()
            )


class Shots(ItemMap):

    ICON = ('icons.flow', 'shot')

    item_prefix = 'p'

    _display_kitsu_settings = flow.BoolParam(False)

    with flow.group('Modify'):
        # create_shot = flow.Child(CreateItemAction)
        clear_shots = flow.Child(ClearMapAction)
    with flow.group('Kitsu'):
        toggle_kitsu_settings = flow.Child(DisplayKitsuSettings)
        update_kitsu_settings = flow.Child(UpdateItemsKitsuSettings)

    @classmethod
    def mapped_type(cls):
        return flow.injection.injectable(Shot)

    def columns(self):
        names = ['Name']

        if self._display_kitsu_settings.get():
            names.extend([
                'Movement',
                'Nb frames',
                'Frame in',
                'Frame out',
                'Multiplan'
            ])

        return names

    def _fill_row_cells(self, row, item):
        row['Name'] = item.name()

        if self._display_kitsu_settings.get():
            row['Nb frames'] = item.kitsu_settings['nb_frames'].get()

            data = item.kitsu_settings['data'].get()

            row['Movement'] = data['movement']
            row['Frame in'] = data['frame_in']
            row['Frame out'] = data['frame_out']
            row['Multiplan'] = data['multiplan']


class Sequence(KitsuSequence):

    ICON = ('icons.flow', 'sequence')

    _map = flow.Parent()

    settings = flow.Child(ContextualView).ui(hidden=True)
    description = flow.Param('')
    shots = flow.Child(Shots).ui(expanded=True)

    def get_default_contextual_edits(self, context_name):
        if context_name == 'settings':
            default_settings = get_contextual_dict(self._map, context_name)
            path = default_settings.get('path', 'UNKNOWN_PATH')

            return dict(
                path=os.path.join(path, self.name()),
                sequence=self.name()
            )


class ClearSequencesAction(ClearMapAction):

    def run(self, button):
        for sequence in self._map.mapped_items():
            for shot in sequence.shots.mapped_items():
                shot.kitsu_settings.clear()

            sequence.shots.clear()
            sequence.kitsu_settings.clear()

        super(ClearSequencesAction, self).run(button)


class Sequences(ItemMap):

    ICON = ('icons.flow', 'sequence')

    item_prefix = 's'

    # create_sequence = flow.Child(CreateItemAction)
    clear_sequences = flow.Child(ClearSequencesAction)
    update_kitsu_settings = flow.Child(UpdateItemsKitsuSettings)

    @classmethod
    def mapped_type(cls):
        return Sequence

    def columns(self):
        return ['Name']

    def _fill_row_cells(self, row, item):
        row['Name'] = item.name()

    def get_default_contextual_edits(self, context_name):
        if context_name == 'settings':
            return dict(
                path='PROD',
                file_category='PROD'
            )