# This file is part of Tryton.  The COPYRIGHT file at the top level of
# this repository contains the full copyright notices and license terms.

import datetime as dt

from sql import Literal
from sql.aggregate import Count
from sql.conditionals import Case, Coalesce
from sql.operators import Equal

from trytond.i18n import gettext
from trytond.model import (
    DeactivableMixin, Exclude, ModelSQL, ModelView, Workflow, fields)
from trytond.pool import Pool, PoolMeta
from trytond.pyson import Eval, If
from trytond.sql.functions import DateRange
from trytond.sql.operators import RangeOverlap
from trytond.tools import grouped_slice, reduce_ids
from trytond.transaction import Transaction

from .exceptions import PromotionCouponNumberDatesError


class Promotion(metaclass=PoolMeta):
    __name__ = 'sale.promotion'

    coupons = fields.One2Many(
        'sale.promotion.coupon', 'promotion', "Coupons",
        domain=[
            ('company', '=', Eval('company', -1)),
            ])

    def get_pattern(self, sale):
        pattern = super().get_pattern(sale)
        if sale.coupons:
            pattern['coupons'] = [c.coupon.id for c in sale.coupons]
        return pattern

    def match(self, pattern):
        if self.coupons:
            pattern = pattern.copy()
            coupons = pattern.pop('coupons', [])
            if not set(coupons).intersection({c.id for c in self.coupons}):
                return False
        return super().match(pattern)

    @classmethod
    def on_modification(cls, mode, promotions, field_names=None):
        pool = Pool()
        Number = pool.get('sale.promotion.coupon.number')
        super().on_modification(mode, promotions, field_names=field_names)
        if mode == 'write' and field_names & {'start_date', 'end_date'}:
            Number.save(list(cls._update_coupon_number_dates(promotions)))

    @classmethod
    def _update_coupon_number_dates(cls, promotions):
        for promotion in promotions:
            for coupon in promotion.coupons:
                for number in coupon.numbers:
                    number.on_change_coupon()
                    yield number


class PromotionCoupon(ModelSQL, ModelView):
    __name__ = 'sale.promotion.coupon'

    number_of_use = fields.Integer(
        "Number of Use", required=True,
        help="How much times a coupon number can be used.\n"
        "0 or below for no limit.")
    per_party = fields.Boolean(
        "Per Party", help="Check to count usage per party.")
    numbers = fields.One2Many(
        'sale.promotion.coupon.number', 'coupon', "Numbers",
        domain=[
            ('company', '=', Eval('company', -1)),
            ],
        filter=[
            ('active', 'in', [True, False]),  # Show inactive numbers
            ])
    promotion = fields.Many2One(
        'sale.promotion', "Promotion", required=True,
        domain=[
            ('company', '=', Eval('company', -1)),
            ])
    company = fields.Many2One('company.company', "Company", required=True)

    @classmethod
    def __setup__(cls):
        super().__setup__()
        cls.__access__.add('promotion')

    @classmethod
    def __register__(cls, module):
        pool = Pool()
        Promotion = pool.get('sale.promotion.coupon')
        table = cls.__table__()
        promotion = Promotion.__table__()
        table_h = cls.__table_handler__(module)
        cursor = Transaction().connection.cursor()

        company_exist = table_h.column_exist('company')

        super().__register__(module)

        # Migration from 7.2: add company
        if not company_exist:
            cursor.execute(*table.update(
                    [table.company],
                    [promotion.select(
                            promotion.company,
                            where=promotion.id == table.promotion)]))

        # Migration from 7.4: remove name
        table_h.not_null_action('name', 'remove')

    @classmethod
    def default_company(cls):
        return Transaction().context.get('company')

    @classmethod
    def default_number_of_use(cls):
        return 0

    @classmethod
    def default_per_party(cls):
        return False

    def get_rec_name(self, name):
        return self.promotion.rec_name

    @classmethod
    def search_rec_name(cls, name, clause):
        return [('promotion.rec_name', *clause[1:])]


class PromotionCouponNumber(DeactivableMixin, ModelSQL, ModelView):
    __name__ = 'sale.promotion.coupon.number'
    _rec_name = 'number'

    number = fields.Char("Number", required=True)
    coupon = fields.Many2One(
        'sale.promotion.coupon', "Coupon", required=True,
        domain=[
            ('company', '=', Eval('company', -1)),
            ])
    company = fields.Many2One('company.company', "Company", required=True)
    start_date = fields.Date("Start Date",
        domain=['OR',
            ('start_date', '<=', If(~Eval('end_date', None),
                    dt.date.max,
                    Eval('end_date', dt.date.max))),
            ('start_date', '=', None),
            ])
    end_date = fields.Date("End Date",
        domain=['OR',
            ('end_date', '>=', If(~Eval('start_date', None),
                    dt.date.min,
                    Eval('start_date', dt.date.min))),
            ('end_date', '=', None),
            ])

    @classmethod
    def __setup__(cls):
        super().__setup__()
        t = cls.__table__()
        cls._sql_constraints += [
            ('dates_number_overlap',
                Exclude(t,
                    (t.company, Equal),
                    (t.number, Equal),
                    (DateRange(t.start_date, t.end_date, '[]'), RangeOverlap)),
                'sale_promotion_coupon.msg_duplicate_numbers'),
            ]
        cls.__access__.add('coupon')
        cls.active = fields.Function(
            cls.active, 'get_active', searcher='search_active')

    @classmethod
    def __register__(cls, module):
        pool = Pool()
        Coupon = pool.get('sale.promotion.coupon')
        Promotion = pool.get('sale.promotion')
        table = cls.__table__()
        coupon = Coupon.__table__()
        promotion = Promotion.__table__()
        table_h = cls.__table_handler__(module)
        cursor = Transaction().connection.cursor()

        start_date_exists = table_h.column_exist('start_date')
        end_date_exists = table_h.column_exist('end_date')
        company_exist = table_h.column_exist('company')

        super().__register__(module)

        # Migration from 7.2: add start_date and end_date
        if not start_date_exists:
            cursor.execute(*table.update(
                    [table.start_date],
                    [coupon
                        .join(promotion,
                            condition=coupon.promotion == promotion.id)
                        .select(
                            promotion.start_date,
                            where=coupon.id == table.coupon)]))
        if not end_date_exists:
            cursor.execute(*table.update(
                    [table.end_date],
                    [coupon
                        .join(promotion,
                            condition=coupon.promotion == promotion.id)
                        .select(
                            promotion.end_date,
                            where=coupon.id == table.coupon)]))

        # Migration from 7.2: add company
        if not company_exist:
            cursor.execute(*table.update(
                    [table.company],
                    [coupon
                        .join(promotion,
                            condition=coupon.promotion == promotion.id)
                        .select(
                            promotion.company,
                            where=coupon.id == table.coupon)]))

    @classmethod
    def default_company(cls):
        return Transaction().context.get('company')

    @classmethod
    def default_start_date(cls):
        return Pool().get('ir.date').today()

    @fields.depends(
        'coupon', '_parent_coupon.promotion',
        '_parent_coupon._parent_promotion.start_date',
        '_parent_coupon._parent_promotion.end_date',
        'start_date', 'end_date')
    def on_change_coupon(self):
        if self.coupon and self.coupon.promotion:
            if start_date := self.coupon.promotion.start_date:
                if not self.start_date or self.start_date < start_date:
                    self.start_date = start_date
            if end_date := self.coupon.promotion.end_date:
                if not self.end_date or self.end_date > end_date:
                    self.end_date = end_date

    @classmethod
    def _active_query(cls):
        pool = Pool()
        Date = pool.get('ir.date')
        Coupon = pool.get('sale.promotion.coupon')
        Sale = pool.get('sale.sale')
        Sale_Number = pool.get('sale.sale-sale.promotion.coupon.number')
        table = cls.__table__()
        coupon = Coupon.__table__()
        sale = Sale.__table__()
        sale_number = Sale_Number.__table__()
        context = Transaction().context
        party = context.get('party')
        if isinstance(party, int):
            party = [party]
        today = Date.today()

        query = (table
            .join(sale_number, 'LEFT',
                condition=table.id == sale_number.number)
            .join(coupon, condition=table.coupon == coupon.id))

        if party:
            query = query.join(sale, 'LEFT',
                condition=(sale_number.sale == sale.id)
                & (sale.party.in_(party)))
            active = Case(
                ((coupon.number_of_use > 0) & (coupon.per_party),
                    Count(sale.id) < coupon.number_of_use),
                ((coupon.number_of_use > 0)
                    & ~Coalesce(coupon.per_party, False),
                    Count(sale_number.sale) < coupon.number_of_use),
                else_=Literal(True))
        else:
            active = Case(
                ((coupon.number_of_use > 0)
                    & ~Coalesce(coupon.per_party, False),
                    Count(sale_number.sale) < coupon.number_of_use),
                else_=Literal(True))

        active &= Coalesce(table.start_date, dt.date.min) <= today
        active &= Coalesce(table.end_date, dt.date.max) >= today

        query = query.select(
            group_by=[table.id, coupon.number_of_use, coupon.per_party])
        return query, table, active

    @classmethod
    def get_active(cls, numbers, name):
        cursor = Transaction().connection.cursor()

        query, table, active = cls._active_query()
        query.columns = [table.id, active]

        result = {}
        for sub_numbers in grouped_slice(numbers):
            query.where = reduce_ids(table.id, map(int, sub_numbers))
            cursor.execute(*query)
            result.update(dict(cursor))
        return result

    @classmethod
    def search_active(cls, name, clause):
        _, operator, value = clause
        Operator = fields.SQL_OPERATORS[operator]

        query, table, active = cls._active_query()
        query.columns = [table.id]
        query.having = Operator(active, value)
        return [('id', 'in', query)]

    @classmethod
    def validate(cls, numbers):
        super().validate(numbers)
        cls.check_dates(numbers)

    @classmethod
    def check_dates(cls, numbers):
        pool = Pool()
        Lang = pool.get('ir.lang')
        lang = Lang.get()
        for number in numbers:
            start_date = number.coupon.promotion.start_date or dt.date.min
            end_date = number.coupon.promotion.end_date or dt.date.max
            if number.start_date and number.start_date < start_date:
                raise PromotionCouponNumberDatesError(gettext(
                        'sale_promotion_coupon'
                        '.msg_promotion_coupon_number_start_date',
                        number=number.rec_name,
                        start_date=lang.strftime(start_date)))
            if number.end_date and number.end_date > end_date:
                raise PromotionCouponNumberDatesError(gettext(
                        'sale_promotion_coupon'
                        '.msg_promotion_coupon_number_end_date',
                        number=number.rec_name,
                        end_date=lang.strftime(end_date)))


class Sale(metaclass=PoolMeta):
    __name__ = 'sale.sale'

    coupons = fields.Many2Many(
        'sale.sale-sale.promotion.coupon.number', 'sale', 'number', "Coupons",
        domain=[
            ('coupon.promotion.company', '=', Eval('company', -1)),
            ],
        context={
            'party': Eval('coupon_parties', []),
            },
        states={
            'readonly': Eval('state') != 'draft',
            },
        depends={'coupon_parties'})
    coupon_parties = fields.Function(fields.Many2Many(
            'party.party', None, None, "Coupon Parties",
            context={
                'company': Eval('company', -1),
                }),
        'on_change_with_coupon_parties')

    @fields.depends(methods=['_coupon_parties'])
    def on_change_with_coupon_parties(self, name=None):
        return list(self._coupon_parties())

    @fields.depends('party')
    def _coupon_parties(self):
        parties = set()
        if self.party:
            parties.add(self.party)
        return parties

    @classmethod
    @ModelView.button
    @Workflow.transition('cancelled')
    def cancel(cls, sales):
        for sale in sales:
            if sale.coupons:
                sale.coupons = []
        cls.save(sales)
        super().cancel(sales)


class Sale_PromotionCouponNumber(ModelSQL):
    __name__ = 'sale.sale-sale.promotion.coupon.number'

    sale = fields.Many2One(
        'sale.sale', "Sale", required=True, ondelete='CASCADE')
    number = fields.Many2One(
        'sale.promotion.coupon.number', "Number",
        required=True, ondelete='RESTRICT')