# This file is part of purchase_discount module for Tryton.
# The COPYRIGHT file at the top level of this repository contains
# the full copyright notices and license terms.
import math
from decimal import Decimal
from sql import Table
from sql.aggregate import Sum
from datetime import date
from trytond.pool import Pool, PoolMeta
from trytond.transaction import Transaction
from trytond.model import ModelView, ModelSQL, fields

__all__ = ['Sale', 'AppDelivery', 'AppSaleOrder']


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

    @classmethod
    def __setup__(cls):
        super(Sale, cls).__setup__()

    @classmethod
    def dash_quote(cls, args, ctx):
        Shop = Pool().get('sale.shop')
        Product = Pool().get('product.product')
        shop_id = ctx['shop']
        shop = Shop(shop_id)
        today = date.today()
        for v in args['lines']:
            del v['id']
            del v['amount']
            v['type'] = 'line'
            product = Product(v['product'])
            v['unit'] = product.template.default_uom.id

        price_list = args.get('price_list', None)
        if price_list:
            price_list = price_list['id']
        to_create = {
            'shop': shop_id,
            'invoice_type': 'P',
            'company': shop.company.id,
            'party': args['party']['id'],
            'sale_date': today,
            'shipment_date': args['shipment_date'],
            'shipment_address': args['shipment_address']['id'],
            'invoice_address': args['shipment_address']['id'],
            'agent': args['agent']['id'],
            'price_list': price_list,
            'payment_term': shop.payment_term.id,
            'state': 'draft',
            'description': args.get('comment', ''),
            'lines': [('create', args['lines'])],
        }
        sale, = cls.create([to_create])
        cls.quote([sale])
        record = args.copy()
        record.update({
            'id': sale.id,
            'state': sale.state,
            'number': sale.number,
            'total_amount': sale.total_amount,
        })
        res = {
            'record': record,
            'msg': 'successful_order',
            'type': 'success',
            'open_modal': True,
        }
        return res

    @classmethod
    def dash_get_line(cls, args, ctx):
        if not args.get('product'):
            return {}

        Product = Pool().get('product.product')
        PriceListLine = Pool().get('product.price_list.line')
        product_id = args['product']['id']
        product = Product(product_id)

        with Transaction().set_context(ctx):
            unit_price = product.list_price

        if args.get('quantity'):
            quantity = int(args.get('quantity'))
        else:
            quantity = 1

        if ctx.get('price_list'):
            price_list_id = ctx.get('price_list')['id']
        else:
            price_list_id = None

        percent_commission = 0
        if price_list_id:
            price_lines = PriceListLine.search([
                ('price_list', '=', price_list_id),
                ('product', '=', product_id),
            ])
            if price_lines:
                price_line = price_lines[0]
                unit_price = float(unit_price)
                unit_price = Decimal(eval(price_line.formula))
                percent_commission = price_line.price_list.percent_commission

        #ADD TAXES
        taxes_ids = [t.id for t in product.customer_taxes_used]
        # res = cls.get_price_with_tax([line], ['amount_w_tax', 'unit_price_w_tax'])
        print('prueba.........')
        res = {
            # 'unit_price_w_tax': math.ceil(res['unit_price_w_tax'][None]),
            # 'amount_w_tax': math.ceil(res['amount_w_tax'][None]),
            # 'taxes': [[('add'), taxes_ids]],
            'unit_price':  math.ceil(unit_price),
            'unit': product.template.default_uom.id,
            'type': 'line',
        }
        if percent_commission:
            res['commission_amount'] = round(
                (unit_price * quantity * percent_commission), 0
            )
        return res

    @classmethod
    def report_sales_day(cls, args, ctx):
        pass

    @classmethod
    def _get_sales_in_period(cls, period, currency_id, in_thousands=False):
        invoice = Table('account_invoice')
        start_date = period.start_date
        end_date = period.end_date

        cursor = Transaction().connection.cursor()
        select = invoice.select(
            Sum(invoice.untaxed_amount_cache),
            limit=1
        )
        select.where = (
            invoice.type == 'out') & (
            invoice.invoice_date >= start_date) & (
            invoice.currency == currency_id) & (
            invoice.invoice_date <= end_date) & (
            invoice.state.in_(['posted', 'paid'])
        )

        cursor.execute(*select)
        values = cursor.fetchone()
        value = 0
        if values and values[0]:
            value = int(values[0])
            if in_thousands:
                value = int(value / 1000)
        return value

    @classmethod
    def report_sales_month(cls, args, ctx):
        pool = Pool()
        Period = pool.get('account.period')
        Currency = pool.get('currency.currency')
        res = {}
        today = date.today()
        periods = Period.search([
            ('start_date', '<=', today),
            ('end_date', '>=', today),
            ('type', '=', 'standard')
        ])
        if not periods:
            return res

        report = args['report']
        period = periods[0]
        selector_periods = Period.search([
            ('fiscalyear', '=', period.fiscalyear.id),
            ('type', '=', 'standard')
        ])
        currency = Currency(ctx['currency'])

        selector = {p.id: p.name for p in selector_periods}

        description = currency.code
        value = cls._get_sales_in_period(period, ctx['currency'],
            report.in_thousands)

        res = {
            'value': value,
            'description': description,
            'selector': selector,
            'default_option': period.id,
            'meta': period.name,
            'in_thousands': report.in_thousands
        }

        return res

    @classmethod
    def report_sales_by_month(cls, args, ctx):
        pool = Pool()
        Fiscalyear = pool.get('account.fiscalyear')
        Currency = pool.get('currency.currency')

        today = date.today()
        fiscalyears = Fiscalyear.search([
            ('start_date', '<=', today),
            ('end_date', '>=', today),
        ])
        if not fiscalyears:
            return {}

        periods = [p for p in fiscalyears[0].periods if p.type == 'standard']

        values = []
        labels = []
        report = args['report']
        for p in periods:
            val = cls._get_sales_in_period(p, ctx['currency'], report.in_thousands)
            if val > 0:
                values.append(val)
                labels.append(p.name)

        currency = Currency(ctx['currency'])

        res = {
            'values': values,
            'labels': labels,
            'description': 'report_sales_by_month',
            'meta': currency.code,
            'in_thousands': report.in_thousands
        }

        return res


class AppDelivery(ModelSQL, ModelView):
    'App Delivery'
    __name__ = 'dash.app.delivery'
    company = fields.Many2One('company.company', 'Company', required=True)

    @classmethod
    def __setup__(cls):
        super(AppDelivery, cls).__setup__()

    @staticmethod
    def default_company():
        return Transaction().context.get('company') or None


class AppSaleOrder(ModelSQL, ModelView):
    'App Sale Order'
    __name__ = 'dash.app.sale_order'
    company = fields.Many2One('company.company', 'Company', required=True)

    @classmethod
    def __setup__(cls):
        super(AppSaleOrder, cls).__setup__()

    @staticmethod
    def default_company():
        return Transaction().context.get('company') or None