from .. import controller
from odoo import http
from odoo.http import request
from datetime import datetime, timedelta
import ast
import logging
import math

_logger = logging.getLogger(__name__)


class Product(controller.Controller):
    prefix = '/api/v1/'

    @http.route(prefix + 'product_variant/<id>/stock', auth='public', methods=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized()
    def get_product_template_stock_by_id(self, **kw):
        id = int(kw.get('id'))
        product = request.env['product.product'].search([('id', '=', id)], limit=1)
        product_sla = request.env['product.sla'].search([('product_variant_id', '=', id)], limit=1)
        
        qty_available = product.qty_onhand_bandengan
        qty_available -= 10
        if qty_available < 10:
            qty_available = 0
            
        qty = 0
        sla_date = '-'
        
        is_altama_product = product.x_manufacture.id in [10,122,89]
        if is_altama_product:
            try:
                qty_altama = request.env['product.template'].get_stock_altama(product.default_code)
                qty_altama -= int(qty_altama * 0.1)
                qty_altama = math.ceil(float(qty_altama))
                qty = qty_altama
                if qty_available > 10:
                    qty += qty_available
                    sla_date = '1 Hari'
                elif qty_altama > 0:
                    sla_date = '2-4 Hari'
                else:
                    sla_date = 'Indent'
            except:
                print('error')
        else:
            qty = qty_available
            sla_date = product_sla.sla or '-'

        data = {
            'qty': qty,
            'sla_date': sla_date,
        }

        return self.response(data, headers=[('Cache-Control', 'max-age=180, private')])


    @http.route(prefix + 'product/template/price/<id>', auth='public', methods=['GET', 'OPTIONS'])
    def get_product_template_price_by_id(self, **kw):
        if not self.authenticate():
            return self.response(code=401, description='Unauthorized')
        id = kw.get('id')
        partner_id = int(kw.get('partner_id', 0))
        product_template = request.env['product.template'].search([('id', '=', id)], limit=1)

        data = {
            'price_include': product_template.product_variant_id._get_website_price_include_tax(),
            'price_exclude': product_template.product_variant_id._get_website_price_exclude_tax(),
            'discount': product_template.product_variant_id._get_website_disc(partner_id),
            'price_include_after_discount': product_template.product_variant_id._get_website_price_after_disc(),
            'price_exclude_after_discount': product_template.product_variant_id._get_website_price_after_disc_and_tax(),
            'tax': product_template.product_variant_id._get_website_tax(),
        }

        if product_template.product_variant_count > 1:
            price_excl_after_disc = price_excl = 0
            for variant in product_template.product_variant_ids:
                if price_excl_after_disc == 0:
                    price_excl = variant._get_website_price_exclude_tax()
                    price_excl_after_disc = variant._get_website_price_after_disc_and_tax()
                elif variant._get_website_price_after_disc_and_tax() < price_excl_after_disc:
                    price_excl_after_disc = variant._get_website_price_after_disc_and_tax()
                    price_excl = variant._get_website_price_exclude_tax()
                else:
                    price_excl_after_disc = price_excl_after_disc
                    price_excl = price_excl

            start_from = {
                'price_start_from': price_excl,
                'price_disc_start_from': price_excl_after_disc
            }
            data.update(start_from)

        return self.response(data, headers=[('Cache-Control', 'max-age=180, private')])
    
    @http.route(prefix + 'product/product/price/<id>', auth='public', methods=['GET', 'OPTIONS'])
    def get_product_product_price_by_id(self, **kw):
        if not self.authenticate():
            return self.response(code=401, description='Unauthorized')
        id = kw.get('id')
        partner_id = int(kw.get('partner_id', 0))   
        product_product = request.env['product.product'].search([('id', '=', id)], limit=1)

        data = {
            'price_include': product_product._get_website_price_include_tax(),
            'price_exclude': product_product._get_website_price_exclude_tax(),
            'discount': product_product._get_website_disc(partner_id),
            'price_include_after_discount': product_product._get_website_price_after_disc(),
            'price_exclude_after_discount': product_product._get_website_price_after_disc_and_tax(),
            'tax': product_product._get_website_tax()
        }

        return self.response(data, headers=[('Cache-Control', 'max-age=180, private')])

    @http.route(prefix + 'new_product', auth='public', methods=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized()
    def get_new_product(self, **kw):
        is_brand_only = int(kw.get('is_brand_only', 0))

        base_url = request.env['ir.config_parameter'].get_param('web.base.url')
        limit_new_products = request.env['ir.config_parameter'].get_param('limit.new.product')
        limit_new_products = int(limit_new_products)
        # current_time = datetime.now()
        # delta_time = current_time - timedelta(days=30)

        # delta_time = delta_time.strftime('%Y-%m-%d %H:%M:%S')
        query_products = [
            ('type', '=', 'product'),
            ('active', '=', True),
            ('image_128', '!=', False),
            ('website_description', '!=', False),
            # ('write_uid', '!=', 1),
            ('x_manufacture', '!=', False),
            # ('create_date', '>=', delta_time),
        ]
        new_products = request.env['product.template'].search(query_products, order='create_date desc', limit=limit_new_products)
        brands = [] 
        for product in new_products:
            brands.append(product.x_manufacture)
        brands = list(dict.fromkeys(brands))

        data = []
        count = 0
        for brand in brands:
            if is_brand_only == 1:
                data.append({
                    'manufacture_id': brand.id,
                    'sequence': brand.sequence if brand.sequence else count,
                    'name': brand.x_name,
                    # 'image': base_url + 'api/image/x_manufactures/x_logo_manufacture/' + str(
                    #     brand.id) if brand.x_logo_manufacture else '',
                    'image': request.env['ir.attachment'].api_image('x_manufactures', 'x_logo_manufacture', brand.id),
                })
                continue

            if count == 11:
                break
            query = [
                ('type', '=', 'product'),
                ('active', '=', True),
                ('x_manufacture', '=', brand.id),
                ('image_128', '!=', False),
                ('website_description', '!=', False),
                # ('write_uid', '!=', 1),
                ('x_manufacture', '!=', False),
                # ('create_date', '>=', delta_time),
            ]
            count_products = request.env['product.template'].search_count(query)
            if count_products < 6:
                _logger.info('Brand Skipped %s' % brand.x_name)
                continue
            products = request.env['product.template'].search(query, order='create_date desc', limit=12)
            data.append({
                'manufacture_id': brand.id,
                'sequence': brand.sequence if brand.sequence else count,
                'name': brand.x_name,
                # 'image': base_url + 'api/image/x_manufactures/x_logo_manufacture/' + str(
                #     brand.id) if brand.x_logo_manufacture else '',
                'image': request.env['ir.attachment'].api_image('x_manufactures', 'x_logo_manufacture', brand.id),
                'products_total': count_products,
                'products': [request.env['product.template'].api_single_response(x) for x in products]
            })
            count += 1
        return self.response(data)

    @http.route(prefix + 'product', auth='public', methods=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized()
    def get_product(self, **kw):
        name = kw.get('name')
        manufactures = kw.get('manufactures')
        categories = kw.get('categories')
        promotions = kw.get('promotions')
        ready_stock = kw.get('ready_stock')
        
        require_betweens = ['name', 'manufactures', 'categories', 'ready_stock', 'promotions']
        is_fulfill =  False
        for required in require_betweens:
            if kw.get(required):
                is_fulfill = True
        
        if not is_fulfill:
            return self.response(code=400, description='name or manufactures or categories or ready_stock or promotions is required')
        
        query = [('sale_ok', '=', True)]
        
        if name:
            name = '%' + name.replace(' ', '%') + '%'
            query += [
                '|',
                ('default_code', 'ilike', name),
                ('name', 'ilike', name),
            ]
        
        if manufactures:
            query.append(('x_manufacture', 'in', [int(x) for x in manufactures.split(',')]))
        
        if categories:
            query.append(('public_categ_ids', 'child_of', [int(x) for x in categories.split(',')]))
            
        if ready_stock == '1':
            query.append(('virtual_qty', '>', 0))
        
        if promotions:
            coupon_programs = request.env['coupon.program'].search([('id', 'in', promotions.split(','))])
            promotion_query = [x for coupon_program in coupon_programs for x in ast.literal_eval(coupon_program.rule_products_domain)]
            query += promotion_query
            
        price_from = kw.get('price_from')
        if price_from and int(price_from):
            query.append(('web_price_sorting', '>=', int(price_from)))
            
        price_to = kw.get('price_to')
        if price_to and int(price_to):
            query.append(('web_price_sorting', '<=', int(price_to)))
        
        product_variants = request.env['product.product'].search(query)
        product_variant_ids = [x.id for x in product_variants]
        
        query = [('product_variant_ids', 'in', product_variant_ids)]
        limit = int(kw.get('limit', 0))
        offset = int(kw.get('offset', 0))
        order = self.get_product_default_order(kw.get('order'))
        
        product_templates = request.env['product.template'].search(query, limit=limit, offset=offset, order=order)
        data = {
            'product_total': request.env['product.template'].search_count(query),
            'products': [request.env['product.template'].api_single_response(x) for x in product_templates]
        }
        return self.response(data)
    
    @http.route(prefix + 'product/solr', auth='public', methods=['GET'])
    @controller.Controller.must_authorized()
    def get_product_solr(self, **kw):
        name = kw.get('name')
        solr_flag = kw.get('flag')
        limit = int(kw.get('limit', 0))
        offset = int(kw.get('offset', 0))
        
        if not solr_flag:
            return self.response(code=400, description='flag is required')
        
        query = [
            ('sale_ok', '=', True),
            ('solr_flag', '=', int(solr_flag))
        ]
        if name:
            name = '%' + name.replace(' ', '%') + '%'
            query += [
                '|',
                ('default_code', 'ilike', name),
                ('name', 'ilike', name),
            ]
        product_templates = request.env['product.template'].search(query, limit=limit, offset=offset)
        data = {
            'product_total': request.env['product.template'].search_count(query),
            'products': [request.env['product.template'].api_single_response(x, with_detail='SOLR') for x in product_templates]
        }
        return self.response(data)
    
    @http.route(prefix + 'product/<id>', auth='public', methods=['GET'])
    @controller.Controller.must_authorized()
    def get_product_by_id(self, **kw):
        id = kw.get('id')
        if not id:
            return self.response(code=400, description='id is required')

        data = []
        id = [int(x) for x in id.split(',')]
        product_templates = request.env['product.template'].search([('id', 'in', id)])
        if product_templates:
            data = [request.env['product.template'].api_single_response(x, with_detail='DEFAULT') for x in product_templates]
        
        return self.response(data)
        
    @http.route(prefix + 'product/<id>/similar', auth='public', methods=['GET', 'OPTIONS'])
    @controller.Controller.must_authorized()
    def get_product_similar_by_id(self, **kw):
        id = kw.get('id')
        if not id:
            return self.response(code=400, description='id is required')
        
        id = int(id)
        product_template = request.env['product.template'].search([('id', '=', id)])
        
        if not product_template: return self.response([])
        
        query = [('id', '!=', id)]
        if product_template.x_manufacture:
            query.append(('x_manufacture', '=', product_template.x_manufacture.id))
        if product_template.public_categ_ids:
            query.append(('public_categ_ids', 'in', [x.id for x in product_template.public_categ_ids]))
        if len(query) == 2:
            query.insert(0, '|')
            
        limit = int(kw.get('limit', 0))
        offset = int(kw.get('offset', 0))
        order = self.get_product_default_order(kw.get('order'))
        product_templates = request.env['product.template'].search(query, limit=limit, offset=offset, order=order)
        
        data = {
            'product_total': request.env['product.template'].search_count(query),
            'products': [request.env['product.template'].api_single_response(x) for x in product_templates]
        }
        return self.response(data)
    
    def get_product_default_order(self, order):
        orders = ['product_rating desc']
        if order != 'price-asc':
            orders.append('web_price_sorting desc')
        if order == 'price-asc': 
            orders.append('web_price_sorting asc')
        elif order == 'latest': 
            orders.append('create_date desc')
        return ','.join(orders)