from .. import controller
from odoo import http
from odoo.http import request
import json

class SaleOrder(controller.Controller):
    prefix = '/api/v1/'
    PREFIX_PARTNER = prefix + 'partner/<partner_id>/'

    @http.route(prefix + "sale_order_number", auth='public', method=['GET', 'OPTIONS'])
    def get_number_sale_order(self, **kw):
        # for midtrans only
        user_token = self.authenticate()
        if not user_token:
            return self.unauthorized_response()

        sale_order_id = int(kw.get('sale_order_id', '0'))
        sale_number = str(kw.get('sale_number', ''))
        if sale_order_id > 0:
            query = [('id', '=', sale_order_id)]
            # sales = request.env['sale.order'].search_read([('id', '=', sale_order_id)], fields=['id', 'name', 'amount_total', 'state'])
            sales = request.env['sale.order'].search(query, limit=1)
        else:
            query = [('name', '=', sale_number)]
            # sales = request.env['sale.order'].search_read([('name', '=', sale_number)], fields=['id', 'name', 'amount_total', 'state'])
            sales = request.env['sale.order'].search(query, limit=1)
        data = []
        for sale in sales:
            product_name = ''
            product_not_in_id = 0
            for line in sale.order_line:
                product_name = line.product_id.name
                product_not_in_id = line.product_id.id
                break
            data.append({
                'id': sale.id,
                'name': sale.name,
                'amount_total': sale.amount_total,
                'state': sale.state,
                'product_name': product_name,
                'product_not_in_id': product_not_in_id,
            })

        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order', auth='public', method=['GET', 'OPTIONS'])
    def get_partner_sale_order(self, **kw):
        user_token = self.authenticate() 
        if not user_token:
            return self.unauthorized_response()

        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'name': [],
            'limit': ['default:0', 'number'],
            'offset': ['default:0', 'number'],
        })
        limit = params['value']['limit']
        offset = params['value']['offset']
        if not user_token['partner_id'] == params['value']['partner_id']:
            return self.unauthorized_response()
        if not params['valid']:
            return self.response(code=400, description=params) 

        partner_child_ids = self.get_partner_child_ids(params['value']['partner_id'])
        domain = [('partner_id', 'in', partner_child_ids)]
        if params['value']['name']:
            name = params['value']['name'].replace(' ', '%')
            domain += [
                '|',
                ('name', 'ilike', '%'+ name +'%'),
                ('partner_purchase_order_name', 'ilike', '%'+ name +'%')
            ]
        sale_orders = request.env['sale.order'].search(domain, offset=offset, limit=limit)
        data = {
            'sale_order_total': request.env['sale.order'].search_count(domain),
            'sale_orders': [request.env['sale.order'].api_v1_single_response(x) for x in sale_orders]
        }
        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>', auth='public', method=['GET', 'OPTIONS'])
    def partner_get_sale_order_detail(self, **kw):
        user_token = self.authenticate() 
        if not user_token:
            return self.unauthorized_response()

        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number']
        })
        if not user_token['partner_id'] == params['value']['partner_id']:
            return self.unauthorized_response()
        if not params['valid']:
            return self.response(code=400, description=params) 
        
        partner_child_ids = self.get_partner_child_ids(params['value']['partner_id'])
        domain = [
            ('id', '=', params['value']['id']),
            ('partner_id', 'in', partner_child_ids)
        ]
        data = {}
        sale_order = request.env['sale.order'].search(domain)
        if sale_order:
            data = request.env['sale.order'].api_v1_single_response(sale_order, context='with_detail')
        
        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>/upload_po', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    def partner_upload_po_sale_order(self, **kw):
        user_token = self.authenticate() 
        if not user_token:
            return self.unauthorized_response()

        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number'],
            'name': [],
            'file': []
        })
        if not user_token['partner_id'] == params['value']['partner_id']:
            return self.unauthorized_response()
        if not params['valid']:
            return self.response(code=400, description=params)
        partner_child_ids = self.get_partner_child_ids(params['value']['partner_id'])
        domain = [
            ('id', '=', params['value']['id']),
            ('partner_id', 'in', partner_child_ids)
        ]
        data = False
        sale_order = request.env['sale.order'].search(domain)
        if sale_order:
            sale_order.partner_purchase_order_name = params['value']['name']
            sale_order.partner_purchase_order_file = params['value']['file']
            data = sale_order.id
        return self.response(data)

    @http.route(PREFIX_PARTNER + 'sale_order/<id>/cancel', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    def partner_cancel_sale_order(self, **kw):
        user_token = self.authenticate() 
        if not user_token:
            return self.unauthorized_response()

        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'id': ['number']
        })
        if not user_token['partner_id'] == params['value']['partner_id']:
            return self.unauthorized_response()
        if not params['valid']:
            return self.response(code=400, description=params)

        partner_child_ids = self.get_partner_child_ids(params['value']['partner_id'])
        domain = [
            ('id', '=', params['value']['id']),
            ('partner_id', 'in', partner_child_ids)
        ]
        data = False
        sale_order = request.env['sale.order'].search(domain)
        if sale_order:
            sale_order.state = 'cancel'
            data = sale_order.id
        return self.response(data)
        
    @http.route(PREFIX_PARTNER + 'sale_order/checkout', auth='public', method=['POST', 'OPTIONS'], csrf=False)
    def create_partner_sale_order(self, **kw):
        user_token = self.authenticate()
        if not user_token:
            return self.unauthorized_response()
        
        product_pricelist_default_discount_id = request.env['ir.config_parameter'].get_param('product.pricelist.default_discount_id')
        product_pricelist_default_discount_id = int(product_pricelist_default_discount_id)

        params = self.get_request_params(kw, {
            'partner_id': ['number'],
            'partner_shipping_id': ['required', 'number'],
            'partner_invoice_id': ['required', 'number'],
            'order_line': ['required', 'default:[]'],
            'po_number': [],
            'po_file': [],
            'type': [],
        })

        if not user_token['partner_id'] == params['value']['partner_id']:
            return self.unauthorized_response()
        
        if not params['valid']:
            return self.response(code=400, description=params)

        parameters = {
            'warehouse_id': 8,
            'carrier_id': 1,
            'sales_tax_id': 23,
            'pricelist_id': product_pricelist_default_discount_id,
            'payment_term_id': 26,
            'team_id': 2,
            'company_id': 1,
            'currency_id': 12,
            'state': 'draft',
            'picking_policy': 'direct',
            'partner_id': params['value']['partner_id'],
            'partner_shipping_id': params['value']['partner_shipping_id'],
            'real_shipping_id': params['value']['partner_shipping_id'],
            'partner_invoice_id': params['value']['partner_invoice_id'],
            'partner_purchase_order_name': params['value']['po_number'],
            'partner_purchase_order_file': params['value']['po_file'],
        }
        if params['value']['type'] == 'sale_order':
            parameters['approval_status'] = 'pengajuan1'
        sale_order = request.env['sale.order'].create([[parameters]])
        order_line = json.loads(params['value']['order_line'])
        parameters = []
        for line in order_line:
            price = request.env['product.pricelist'].compute_price(product_pricelist_default_discount_id, line['product_id'])
            parameters.append({
                'company_id': 1,
                'order_id': sale_order.id,
                'product_id': line['product_id'],
                'product_uom_qty': line['quantity'],
                'price_subtotal': price['price'],
                'discount': price['discount_percentage']
            })
        request.env['sale.order.line'].create(parameters)
        return self.response({
            'id': sale_order.id,
            'name': sale_order.name
        })
        
    @http.route('/api/sale_order/invoiced', auth='public', methods=['GET'])
    def get_sale_order_invoiced_by_partner_id(self, **kw):
        if not self.authenticate():
            return self.unauthorized_response()

        partner_id = kw.get('partner_id')
        if not partner_id:
            return self.response(code=400, description='Field partner_id is required')

        partner_id = int(partner_id)
        # Get company member by partner_id
        parent_partner_id = request.env['res.partner'].search([('id', '=', partner_id)], limit=1).parent_id.id
        partner_childs = request.env['res.partner'].search([('parent_id', '=', int(parent_partner_id))])
        partner_child_ids = [v['id'] for v in partner_childs] + [partner_id]

        # Get sale order by company member and invoiced
        data = []
        default_domain = [
            ('partner_id', 'in', partner_child_ids),
            ('state', 'in', ['sale', 'done'])
        ]
        sale_orders = self.search_filter('sale.order', kw, default_domain)
        for sale_order in sale_orders:
            pickings = []
            for picking in sale_order.picking_ids:
                if picking.state in ['confirmed', 'assigned', 'done']:
                    pickings.append({
                        'id': picking.id,
                        'name': picking.name,
                        'delivery_address': picking.partner_id.street,
                        'delivery_tracking_no': picking.delivery_tracking_no,
                        'delivery_status': picking.delivery_status
                    })

            data.append({
                'id': sale_order.id,
                'name': sale_order.name,
                'amount_total': sale_order.amount_total,
                'salesperson': sale_order.user_id.name,
                'date_order': self.time_to_str(sale_order.date_order, '%d/%m/%Y'),
                'pickings': pickings,
                'access_token': sale_order.access_token
            })
        return self.response(data)

    @http.route('/api/sale_order/invoiced/detail', auth='public', methods=['GET'])
    def get_sale_order_invoiced_detail_by_partner(self, **kw):
        if not self.authenticate():
            return self.unauthorized_response()

        id = kw.get('id')
        partner_id = kw.get('partner_id')
        if not id:
            return self.response(code=400, description='Field id is required')
        if not partner_id:
            return self.response(code=400, description='Field partner_id is required')

        default_domain = [
            ('id', '=', id),
            ('state', 'in', ['sale', 'done'])
        ]
        parent_partner_id = request.env['res.partner'].search([('id', '=', int(partner_id))], limit=1).parent_id.id
        partner_childs = request.env['res.partner'].search([('parent_id', '=', int(parent_partner_id))])
        partner_child_ids = [v['id'] for v in partner_childs] + [int(partner_id)]
        default_domain.append(('partner_id', 'in', partner_child_ids))

        sale_order = self.search_filter('sale.order', kw, default_domain)
        orders = []
        for order in sale_order.order_line:
            orders.append({
                'name': order.name,
                'product_qty': order.product_qty,
                'price_unit': order.price_unit,
                'price_tax': order.price_tax,
                'price_total': order.price_total,
                'price_subtotal': order.price_subtotal,
                'tax': order.tax_id.name,
                'discount': order.discount,
            })

        data = {
            'id': sale_order.id,
            'name': sale_order.name,
            'carrier': sale_order.carrier_id.name,
            'partner': {
                'id': sale_order.partner_id.id,
                'name': sale_order.partner_id.name,
                'mobile': sale_order.partner_id.mobile,
                'email': sale_order.partner_id.email
            },
            'delivery_address': sale_order.partner_shipping_id.street,
            'delivery_method': sale_order.carrier_id.name,
            'payment_term': sale_order.payment_term_id.name,
            'salesperson': sale_order.user_id.name,
            'date_order': self.time_to_str(sale_order.date_order, '%d/%m/%Y %H:%M:%S'),
            'note': sale_order.note,
            'amount_untaxed': sale_order.amount_untaxed,
            'amount_tax': sale_order.amount_tax,
            'amount_total': sale_order.amount_total,
            'orders': orders
        }

        return self.response(data)