# :coding: utf-8
# :copyright: Copyright (c) 2017 ftrack

import sys
import argparse
import logging

import ftrack_api

import ftrack_action_handler.action


class EditMetaData(ftrack_action_handler.action.BaseAction):
    '''Edit meta data action.'''

    #: Action identifier.
    identifier = 'ftrack.edit.meta.data'

    #: Action label.
    label = 'Edit metadata'

    #: Action description.
    description = 'Edit meta data on entity'

    def validate_selection(self, session, entities):
        '''Return if *entities* is a valid selection.'''
        if (len(entities) != 1):
            # If entities contains more than one item return early since
            # metadata cannot be edited for several entites at the same time.
            return False

        entity_type, entity_id = entities[0]
        if (
            entity_type not in session.types or
            'metadata' not in session.types[entity_type].attributes.keys()
        ):
            # Return False if the target entity does not have a metadata
            # attribute.
            return False

        return True

    def discover(self, session, entities, event):
        '''Return True if action is valid.'''
        self.logger.info('Got selection: {0}'.format(entities))
        return self.validate_selection(session, entities)

    def interface(self, session, entities, event):
        '''Return interface.'''
        values = event['data'].get('values', {})

        if not values:
            items = []

            entity_type, entity_id = entities[0]
            entity = session.get(entity_type, entity_id)

            # Refresh metadata collection.
            del entity['metadata']
            session.populate(entity, 'metadata.key, metadata.value')

            for key, value in entity['metadata'].items():
                items.append({
                    'label': key,
                    'type': 'textarea',
                    'name': key,
                    'value': value
                })

            if not items:
                items.append({
                    'type': 'label',
                    'value': '*No metadata found on entity.*'
                })

            return items

    def launch(self, session, entities, event):
        '''Launch edit meta data action.'''
        try:
            input_values = event['data']['values']
        except KeyError:
            input_values = None

        entity_type, entity_id = entities[0]
        entity = session.get(entity_type, entity_id)
        if input_values:
            for key, value in input_values.items():
                if entity['metadata'][key] != value:
                    # Only update if changed.
                    entity['metadata'][key] = value

        try:
            session.commit()
        except:
            # Commit failed, rollback session and re-raise.
            session.rollback()
            raise

        return True


def register(session, **kw):
    '''Register plugin. Called when used as an plugin.'''

    # Validate that session is an instance of ftrack_api.Session. If not,
    # assume that register is being called from an old or incompatible API and
    # return without doing anything.
    if not isinstance(session, ftrack_api.session.Session):
        return

    action_handler = EditMetaData(session)
    action_handler.register()


def main(arguments=None):
    '''Set up logging and register action.'''
    if arguments is None:
        arguments = []

    parser = argparse.ArgumentParser()
    # Allow setting of logging level from arguments.
    loggingLevels = {}
    for level in (
        logging.NOTSET, logging.DEBUG, logging.INFO, logging.WARNING,
        logging.ERROR, logging.CRITICAL
    ):
        loggingLevels[logging.getLevelName(level).lower()] = level

    parser.add_argument(
        '-v', '--verbosity',
        help='Set the logging output verbosity.',
        choices=loggingLevels.keys(),
        default='info'
    )
    namespace = parser.parse_args(arguments)

    # Set up basic logging
    logging.basicConfig(level=loggingLevels[namespace.verbosity])

    session = ftrack_api.Session()
    register(session)

    # Wait for events
    logging.info(
        'Registered actions and listening for events. Use Ctrl-C to abort.'
    )
    session.event_hub.wait()


if __name__ == '__main__':
    raise SystemExit(main(sys.argv[1:]))