#This file is part systemlogics_modula module for Tryton.
#The COPYRIGHT file at the top level of this repository contains
#the full copyright notices and license terms.
from trytond.pool import Pool, PoolMeta
from trytond.model import  ModelView, fields
from trytond.transaction import Transaction
from trytond.pyson import Eval
from trytond.wizard import Wizard, StateView, Button, StateTransition
from trytond.tools import grouped_slice
import logging

__all__ = ['ShipmentIn', 'ShipmentOut', 'ShipmentOutReturn', 'ShipmentInternal',
    'ShipmentOutSystemlogicsModulaExportStart', 'ShipmentOutSystemlogicsModulaExport',
    'ShipmentOutSystemlogicsModulaCheckStart', 'ShipmentOutSystemlogicsModulaCheck']

logger = logging.getLogger(__name__)


class ShipmentIn(metaclass=PoolMeta):
    __name__ = 'stock.shipment.in'
    systemlogics_modula = fields.Boolean('SystemLogics Modula')

    @classmethod
    def __setup__(cls):
        super(ShipmentIn, cls).__setup__()
        cls._buttons.update({
            'do_systemlogics_modula': {
                'invisible': Eval('state').in_(['draft', 'cancel']),
                },
            })

    @staticmethod
    def default_systemlogics_modula():
        return False

    @classmethod
    def copy(cls, shipments, default=None):
        if default is None:
            default = {}
        default = default.copy()
        default['systemlogics_modula'] = None
        return super(ShipmentIn, cls).copy(shipments, default=default)

    @classmethod
    def generate_systemlogics_modula(cls, shipments):
        '''Active System Logics process when a move location is systemlogics marked'''
        SystemLogicsModula = Pool().get('systemlogics.modula')

        deposit_shipments = []
        for s in shipments:
            systemLogics = False
            for move in s.inventory_moves:
                if move.to_location.systemlogics_modula:
                    systemLogics = True

            if systemLogics:
                deposit_shipments.append(s)

        if deposit_shipments:
            cls.write(deposit_shipments, {'systemlogics_modula': True})

            # Force not get a rollback to generate XML file
            shipment_ids = [s.id for s in deposit_shipments]
            Transaction().commit()
            # Search shipment ID to sure not have a rollback
            shipments = cls.search([
                ('id', 'in', shipment_ids),
                ])
            SystemLogicsModula.imp_ordini(
                shipments, template='IMP_ORDINI_IN', type_='V')

    @classmethod
    @ModelView.button
    def do_systemlogics_modula(cls, shipments):
        cls.generate_systemlogics_modula(shipments)


class ShipmentOut(metaclass=PoolMeta):
    __name__ = 'stock.shipment.out'
    systemlogics_modula = fields.Boolean('SystemLogics Modula')
    systemlogics_modula_completed = fields.Boolean(
        'SystemLogics Modula Completed')
    systemlogics_modula_sended = fields.Boolean('SystemLogics Modula Sended')
    ship_create_date = fields.Function(fields.DateTime('Create Date'),
        'get_ship_create_date')

    @staticmethod
    def default_systemlogics_modula():
        return False

    @staticmethod
    def default_systemlogics_modula_completed():
        return False

    @staticmethod
    def default_systemlogics_modula_sended():
        return False

    def get_ship_create_date(self, name):
        return self.create_date

    @classmethod
    def copy(cls, shipments, default=None):
        if default is None:
            default = {}
        default = default.copy()
        default['systemlogics_modula'] = False
        default['systemlogics_modula_completed'] = False
        default['systemlogics_modula_sended'] = False
        return super(ShipmentOut, cls).copy(shipments, default=default)

    @classmethod
    def generate_systemlogics_modula_file(cls, shipments):
        SystemLogicsModula = Pool().get('systemlogics.modula')

        # Force not get a rollback to generate XML file
        shipment_ids = [s.id for s in shipments]
        Transaction().commit()

        # Search shipment ID to sure not have a rollback
        shipments = cls.search([
            ('id', 'in', shipment_ids),
            ], order=[('systemlogics_modula_completed', 'DESC')])
        SystemLogicsModula.imp_ordini(
            shipments, template='IMP_ORDINI_OUT', type_='P')

    @classmethod
    def check_systemlogics_modula(cls, shipments):
        pool = Pool()
        Configuration = pool.get('stock.configuration')

        config = Configuration(1)
        if not (Transaction().context.get('generate_systemlogics_modula',
                config.try_generate_systemlogics_modula)):
            return

        to_write = []
        values = {
            'systemlogics_modula': True
            }
        for shipment in shipments:
            if hasattr(shipment, 'review'):
                if shipment.review:
                    continue
            systemLogics = False
            completed = True
            for move in shipment.inventory_moves:
                if move.from_location.systemlogics_modula:
                    systemLogics = True
                else:
                    completed = False
            if systemLogics:
                values = values.copy()
                if completed:
                    values['systemlogics_modula_completed'] = True
                else:
                    values['systemlogics_modula_completed'] = False
                to_write.extend(([shipment], values))
        if to_write:
            cls.write(*to_write)

    @classmethod
    def generate_systemlogics_modula(cls, shipments):
        '''Generate SystemLogics Modula'''
        Configuration = Pool().get('stock.configuration')

        config = Configuration(1)
        if not (Transaction().context.get('generate_systemlogics_modula',
                config.try_generate_systemlogics_modula)):
            return

        to_write = []
        shipments_modula = []
        value = {
            'systemlogics_modula_sended': True
            }
        for shipment in shipments:
            if hasattr(shipment, 'review'):
                if shipment.review:
                    continue
                shipments_modula.append(shipment)
                to_write.extend(([shipment], value))

        if shipments_modula:
            cls.write(*to_write)
            cls.generate_systemlogics_modula_file(shipments_modula)

    @classmethod
    def assign(cls, shipments):
        super(ShipmentOut, cls).assign(shipments)
        assigned = [s for s in shipments if s.state == 'assigned']
        cls.check_systemlogics_modula(assigned)
        cls.generate_systemlogics_modula(assigned)

    @classmethod
    def check_systemlogics_modula_scheduler(cls, args=None):
        '''
        This method is intended to be called from ir.cron
        args: warehouse ids [ids]
        '''
        pool = Pool()
        Configuration = pool.get('stock.configuration')
        config = Configuration(1)

        domain = [
            ('state', '=', 'assigned'),
            ('systemlogics_modula', '=', False),
            ]
        if args:
            domain.append(
                ('warehouse', 'in', args),
                )
        shipments = cls.search(domain)

        len_ships = len(shipments)
        logger.info(
            'Scheduler Try Check Systemlogics Modula. Total: %s' % (
                len_ships))
        if len_ships:
            blocs = 1
            slice_systemlogics_modula = (config.slice_systemlogics_modula or
                len_ships)
            with Transaction().set_context(generate_systemlogics_modula=True):
                for sub_shipments in grouped_slice(shipments,
                        slice_systemlogics_modula):
                    logger.info('Start bloc %s of %s.' % (
                            blocs, len_ships/slice_systemlogics_modula))
                    cls.check_systemlogics_modula(list(sub_shipments))
                    logger.info('End bloc %s.' % blocs)
                    blocs += 1
        logger.info('End Scheduler Try Check Systemlogics Modula.')

    @classmethod
    def generate_systemlogics_modula_scheduler(cls, args=None):
        '''
        This method is intended to be called from ir.cron
        args: warehouse ids [ids]
        '''
        pool = Pool()
        Configuration = pool.get('stock.configuration')
        config = Configuration(1)

        domain = [
            ('state', '=', 'assigned'),
            ('systemlogics_modula', '=', True),
            ('systemlogics_modula_sended', '=', False),
            ]
        if args:
            domain.append(
                ('warehouse', 'in', args),
                )
        shipments = cls.search(domain)

        len_ships = len(shipments)
        logger.info(
            'Scheduler Try generate Systemlogics Modula. Total: %s' % (
                len_ships))
        if len_ships:
            blocs = 1
            slice_systemlogics_modula = (config.slice_systemlogics_modula or
                len_ships)
            with Transaction().set_context(generate_systemlogics_modula=True):
                for sub_shipments in grouped_slice(shipments,
                        slice_systemlogics_modula):
                    logger.info('Start bloc %s of %s.' % (
                            blocs, len_ships/slice_systemlogics_modula))
                    cls.generate_systemlogics_modula(list(sub_shipments))
                    logger.info('End bloc %s.' % blocs)
                    blocs += 1
        logger.info('End Scheduler Try generate Systemlogics Modula.')


class ShipmentOutReturn(metaclass=PoolMeta):
    __name__ = 'stock.shipment.out.return'
    systemlogics_modula = fields.Boolean('SystemLogics Modula')

    @classmethod
    def __setup__(cls):
        super(ShipmentOutReturn, cls).__setup__()
        cls._buttons.update({
            'do_systemlogics_modula': {
                'invisible': Eval('state').in_(['draft', 'cancel']),
                },
            })

    @staticmethod
    def default_systemlogics_modula():
        return False

    @classmethod
    def copy(cls, shipments, default=None):
        if default is None:
            default = {}
        default = default.copy()
        default['systemlogics_modula'] = None
        return super(ShipmentOutReturn, cls).copy(shipments, default=default)

    @classmethod
    def generate_systemlogics_modula(cls, shipments):
        '''Active System Logics process when a move location is systemlogics marked'''
        SystemLogicsModula = Pool().get('systemlogics.modula')

        deposit_shipments = []
        for s in shipments:
            systemLogics = False
            for move in s.inventory_moves:
                if move.to_location.systemlogics_modula:
                    systemLogics = True

            if systemLogics:
                deposit_shipments.append(s)

        if deposit_shipments:
            cls.write(deposit_shipments, {'systemlogics_modula': True})

            # Force not get a rollback to generate XML file
            shipment_ids = [s.id for s in deposit_shipments]
            Transaction().commit()
            # Search shipment ID to sure not have a rollback
            shipments = cls.search([
                ('id', 'in', shipment_ids),
                ])
            SystemLogicsModula.imp_ordini(
                shipments, template='IMP_ORDINI_IN', type_='V')

    @classmethod
    @ModelView.button
    def do_systemlogics_modula(cls, shipments):
        cls.generate_systemlogics_modula(shipments)


class ShipmentInternal(metaclass=PoolMeta):
    __name__ = 'stock.shipment.internal'
    systemlogics_modula = fields.Boolean('SystemLogics Modula')

    @staticmethod
    def default_systemlogics_modula():
        return False

    @classmethod
    def copy(cls, shipments, default=None):
        if default is None:
            default = {}
        default = default.copy()
        default['systemlogics_modula'] = None
        return super(ShipmentInternal, cls).copy(shipments, default=default)

    @classmethod
    def generate_systemlogics_modula(cls, shipments):
        '''Active System Logics process when a move location is systemlogics marked'''
        SystemLogicsModula = Pool().get('systemlogics.modula')

        extract_shipments = []
        deposit_shipments = []
        for s in shipments:
            if s.from_location.systemlogics_modula:
                extract_shipments.append(s)
            if s.to_location.systemlogics_modula:
                deposit_shipments.append(s)

        if extract_shipments or deposit_shipments:
            cls.write(extract_shipments + deposit_shipments, {'systemlogics_modula': True})

            # Force not get a rollback to generate XML file
            extract_shipments_ids = [shipment.id for shipment in extract_shipments]
            deposit_shipments_ids = [shipment.id for shipment in deposit_shipments]
            Transaction().commit()

            if extract_shipments_ids:
                # Search shipment ID to sure not have a rollback
                ext_shipments = cls.search([
                    ('id', 'in', extract_shipments_ids),
                    ])
                SystemLogicsModula.imp_ordini(
                    ext_shipments, template='IMP_ORDINI_INTERNAL', type_='P')
            if deposit_shipments_ids:
                # Search shipment ID to sure not have a rollback
                dep_shipments = cls.search([
                    ('id', 'in', deposit_shipments_ids),
                    ])
                SystemLogicsModula.imp_ordini(
                    dep_shipments, template='IMP_ORDINI_INTERNAL', type_='V')

    @classmethod
    def assign(cls, shipments):
        super(ShipmentInternal, cls).assign(shipments)
        cls.generate_systemlogics_modula(shipments)


class ShipmentOutSystemlogicsModulaExportStart(ModelView):
    'Customer shipments export Systemlogics Modula Start'
    __name__ = 'stock.shipment.out.systemlogics.modula.export.start'
    shipments = fields.Many2Many('stock.shipment.out', None, None, 'Shipments',
        required=True, domain=[
            ('state', '=', 'assigned'),
            ('systemlogics_modula', '=', True),
            ('systemlogics_modula_sended', '=', False),
            ],
        help='Assigned customer shipments to export Systemlogics Modula.')

    @classmethod
    def default_shipments(cls):
        ShipmentOut = Pool().get('stock.shipment.out')

        active_ids = Transaction().context.get('active_ids', [])
        domain = []
        domain.extend(cls.shipments.domain)
        if active_ids:
            domain.append(
                ('id', 'in', active_ids)
                )
        shipments = ShipmentOut.search(domain)
        return [s.id for s in shipments]


class ShipmentOutSystemlogicsModulaExport(Wizard):
    'Customer shipments export Systemlogics Modula'
    __name__ = 'stock.shipment.out.systemlogics.modula.export'

    start = StateView('stock.shipment.out.systemlogics.modula.export.start',
        'systemlogics_modula.shipment_out_export_form', [
            Button('Cancel', 'end', 'tryton-cancel'),
            Button('Export', 'export', 'tryton-ok', True),
            ])
    export = StateTransition()

    def transition_export(self):
        ShipmentOut = Pool().get('stock.shipment.out')

        shipments = list(self.start.shipments)
        if shipments:
            with Transaction().set_context(generate_systemlogics_modula=True):
                ShipmentOut.generate_systemlogics_modula(shipments)
        return 'end'


class ShipmentOutSystemlogicsModulaCheckStart(ModelView):
    'Customer shipments check Systemlogics Modula Start'
    __name__ = 'stock.shipment.out.systemlogics.modula.check.start'
    shipments = fields.Many2Many('stock.shipment.out', None, None, 'Shipments',
        required=True, domain=[
            ('state', '=', 'assigned'),
            ],
        help='Assigned customer shipments to check Systemlogics Modula.')

    @staticmethod
    def default_shipments():
        ShipmentOut = Pool().get('stock.shipment.out')

        active_ids = Transaction().context.get('active_ids', [])
        domain = [
            ('state', '=', 'assigned'),
            ('systemlogics_modula', '=', False),
            ]
        if active_ids:
            domain.append(
                ('id', 'in', active_ids)
                )
        shipments = ShipmentOut.search(domain)
        return [s.id for s in shipments]


class ShipmentOutSystemlogicsModulaCheck(Wizard):
    'Customer shipments check Systemlogics Modula'
    __name__ = 'stock.shipment.out.systemlogics.modula.check'

    start = StateView('stock.shipment.out.systemlogics.modula.check.start',
        'systemlogics_modula.shipment_out_check_form', [
            Button('Cancel', 'end', 'tryton-cancel'),
            Button('Check', 'check', 'tryton-ok', True),
            ])
    check = StateTransition()

    def transition_check(self):
        ShipmentOut = Pool().get('stock.shipment.out')

        shipments = list(self.start.shipments)
        if shipments:
            with Transaction().set_context(generate_systemlogics_modula=True):
                ShipmentOut.check_systemlogics_modula(shipments)
        return 'end'