import json
import base64
import requests
from odoo import models, api
from odoo.addons.sf_base.commons.common import Common
from odoo.exceptions import UserError


def get_suitable_machining_method_names(item):
    suitable_machining_method_names = []
    for suitable_machining_method_id in item.suitable_machining_method_ids:
        if suitable_machining_method_id:
            suitable_machining_method_names.append(suitable_machining_method_id.name)
    return suitable_machining_method_names


def get_cutting_direction_names(item):
    cutting_direction_names = []
    for cutting_direction_id in item.cutting_direction_ids:
        if cutting_direction_id:
            cutting_direction_names.append(cutting_direction_id.name)
    return cutting_direction_names


def get_suitable_coolant_names(item):
    suitable_coolant_names = []
    for suitable_coolant_id in item.suitable_coolant_ids:
        if suitable_coolant_id:
            suitable_coolant_names.append(suitable_coolant_id.name)
    return suitable_coolant_names


class StockLot(models.Model):
    _inherit = 'stock.lot'
    _description = '刀具物料序列号注册'

    def enroll_tool_material_stock(self):
        sf_sync_config = self.env['res.config.settings'].get_values()
        token = sf_sync_config['token']
        sf_secret_key = sf_sync_config['sf_secret_key']
        headers = Common.get_headers(self, token, sf_secret_key)
        str_url = sf_sync_config['sf_url'] + "/api/tool_material_stock/create"
        objs_all = self.env['stock.lot'].search([('id', '=', self.id)])
        tool_material_stock_list = []
        if objs_all:
            for item in objs_all:
                val = {
                    'name': item.name,
                    'tool_material_status': item.tool_material_status,
                    'location': [] if not item.quant_ids else item.quant_ids[-1].location_id.name,
                    'tool_material_search_id': item.tool_material_search_id.id,
                }
                tool_material_stock_list.append(val)
            kw = json.dumps(tool_material_stock_list, ensure_ascii=False)
            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
            ret = r.json()
            if ret.get('code') == 200:
                return '刀具物料序列号注册成功'
        else:
            raise UserError("没有注册刀具物料序列号信息")


class ToolMaterial(models.Model):
    _inherit = 'sf.tool.material.search'
    _description = '刀具物料注册'

    crea_url = '/api/tool_material/create'

    def enroll_tool_material(self):
        sf_sync_config = self.env['res.config.settings'].get_values()
        token = sf_sync_config['token']
        sf_secret_key = sf_sync_config['sf_secret_key']
        headers = Common.get_headers(self, token, sf_secret_key)
        str_url = sf_sync_config['sf_url'] + self.crea_url
        objs_all = self.search([('id', '=', self.id)])
        tool_material_list = []
        if objs_all:
            for item in objs_all:
                val = {
                    'name': item.name,
                    'id': item.id,
                    'cutting_tool_material_code': item.cutting_tool_material_id.code,
                    'cutting_tool_standard_library_code': item.cutting_tool_standard_library_id.code,
                    'specification_name': item.specification_id.name,
                    'image': '' if not item.image else base64.b64encode(item.image).decode('utf-8'),
                    'number': item.number,
                    'usable_num': item.usable_num,
                    'have_been_used_num': item.have_been_used_num,
                    'scrap_num': item.scrap_num
                }
                tool_material_list.append(val)
            kw = json.dumps(tool_material_list, ensure_ascii=False)
            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
            ret = r.json()
            if ret.get('code') == 200:
                return '刀具物料注册成功'
        else:
            raise UserError("没有注册刀具物料信息")

    @api.model_create_multi
    def create(self, vals_list):
        records = super(ToolMaterial, self).create(vals_list)
        for record in records:
            if record:
                record.enroll_tool_material()
        return records


class FunctionalCuttingToolEntity(models.Model):
    _inherit = 'sf.functional.cutting.tool.entity'
    _description = '功能刀具列表注册'

    crea_url = "/api/functional_tool_entity/create"

    # 注册同步功能刀具列表
    def enroll_functional_tool_entity(self):
        sf_sync_config = self.env['res.config.settings'].get_values()
        token = sf_sync_config['token']
        sf_secret_key = sf_sync_config['sf_secret_key']
        headers = Common.get_headers(self, token, sf_secret_key)
        str_url = sf_sync_config['sf_url'] + self.crea_url
        objs_all = self.env['sf.functional.cutting.tool.entity'].search([('id', '=', self.id)])
        functional_tool_list = []
        if objs_all:
            for item in objs_all:
                val = {
                    'id': item.id,
                    'code': item.code,
                    'name': item.name,
                    'rfid': item.rfid,
                    'tool_groups_name': item.tool_groups_id.name,
                    'barcode': item.barcode_id.name,
                    'cutting_tool_type_code': item.sf_cutting_tool_type_id.code,
                    'functional_tool_diameter': item.functional_tool_diameter,
                    'knife_tip_r_angle': item.knife_tip_r_angle,
                    'coarse_middle_thin': item.coarse_middle_thin,
                    'new_former': item.new_former,
                    'tool_loading_length': item.tool_loading_length,
                    'functional_tool_length': item.functional_tool_length,
                    'effective_length': item.effective_length,
                    'max_lifetime_value': item.max_lifetime_value,
                    'alarm_value': item.alarm_value,
                    'used_value': item.used_value,
                    'functional_tool_status': item.functional_tool_status,
                    'current_location': item.current_location,
                    'image': '' if not item.image else base64.b64encode(item.image).decode('utf-8'),
                    'whether_standard_knife': item.whether_standard_knife,
                    'L_D_number': item.L_D_number,
                    'hiding_length': item.hiding_length,
                    'cut_time': item.cut_time,
                    'cut_length': item.cut_length,
                    'cut_number': item.cut_number,
                    'cutting_tool_integral_model_id': item.cutting_tool_integral_model_id.tool_material_id,
                    'cutting_tool_blade_model_id': item.cutting_tool_blade_model_id.tool_material_id,
                    'cutting_tool_cutterbar_model_id': item.cutting_tool_cutterbar_model_id.tool_material_id,
                    'cutting_tool_cutterpad_model_id': item.cutting_tool_cutterpad_model_id.tool_material_id,
                    'cutting_tool_cutterhandle_model_id': item.cutting_tool_cutterhandle_model_id.tool_material_id,
                    'cutting_tool_cutterhead_model_id': item.cutting_tool_cutterhead_model_id.tool_material_id,
                    'suitable_machining_method_names': get_suitable_machining_method_names(item),
                    'blade_tip_characteristics_name': item.blade_tip_characteristics_id.name,
                    'handle_type_name': item.handle_type_id.name,
                    'cutting_direction_names': get_cutting_direction_names(item),
                    'suitable_coolant_names': get_suitable_coolant_names(item),
                    'active': item.active,
                }
                functional_tool_list.append(val)
            kw = json.dumps(functional_tool_list, ensure_ascii=False)
            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
            ret = r.json()
            if ret.get('code') == 200:
                return "功能刀具注册成功"
        else:
            raise UserError("没有注册功能刀具信息")

    @api.model_create_multi
    def create(self, vals_list):
        records = super(FunctionalCuttingToolEntity, self).create(vals_list)
        for record in records:
            if record:
                record.enroll_functional_tool_entity()
        return records

    def write(self, vals):
        res = super().write(vals)
        if vals.get('current_location'):
            self.enroll_functional_tool_entity()
        return res


class FunctionalToolWarning(models.Model):
    _inherit = 'sf.functional.tool.warning'
    _description = '功能刀具预警注册'

    crea_url = "/api/functional_tool_warning/create"

    # 注册同步功能刀具预警
    def enroll_functional_tool_warning(self):
        sf_sync_config = self.env['res.config.settings'].get_values()
        token = sf_sync_config['token']
        sf_secret_key = sf_sync_config['sf_secret_key']
        headers = Common.get_headers(self, token, sf_secret_key)
        str_url = sf_sync_config['sf_url'] + self.crea_url
        objs_all = self.env['sf.functional.tool.warning'].search([('id', '=', self.id)])
        tool_warning_list = []
        if objs_all:
            for item in objs_all:
                val = {
                    'id': item.id,
                    'name': item.name,
                    'code': item.code,
                    'rfid': item.rfid,
                    'tool_groups_name': item.tool_groups_id.name,
                    'production_line': item.production_line_id.name,
                    'machine_tool_id': item.maintenance_equipment_id.code,
                    'machine_tool_code': item.machine_tool_code,
                    'cutter_spacing_code': item.cutter_spacing_code_id.code,
                    'functional_tool_name': item.name,
                    'barcode': item.barcode_id.name,
                    'mrs_cutting_tool_type_code': item.mrs_cutting_tool_type_id.code,
                    'diameter': item.diameter,
                    'knife_tip_r_angle': item.knife_tip_r_angle,
                    'install_tool_time': item.install_tool_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'on_board_time': item.on_board_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'max_lifetime_value': item.max_lifetime_value,
                    'alarm_value': item.alarm_value,
                    'used_value': item.used_value,
                    'functional_tool_status': item.functional_tool_status,
                    'alarm_time': item.alarm_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'dispose_user': item.dispose_user,
                    'dispose_time': item.dispose_time,
                    'dispose_func': item.dispose_func,
                }
                tool_warning_list.append(val)
            kw = json.dumps(tool_warning_list, ensure_ascii=False)
            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
            ret = r.json()
            if ret.get('code') == 200:
                return "功能刀具预警注册成功"
        else:
            raise UserError("没有注册功能刀具预警信息")

    @api.model_create_multi
    def create(self, vals_list):
        records = super(FunctionalToolWarning, self).create(vals_list)
        for record in records:
            if record:
                record.enroll_functional_tool_warning()
        return records


class StockMoveLine(models.Model):
    _inherit = 'stock.move.line'
    _description = '功能刀具出入库记录注册'

    crea_url = "/api/functional_tool_move/create"

    # 注册同步功能刀具出入库记录
    def enroll_functional_tool_move(self):
        sf_sync_config = self.env['res.config.settings'].get_values()
        token = sf_sync_config['token']
        sf_secret_key = sf_sync_config['sf_secret_key']
        headers = Common.get_headers(self, token, sf_secret_key)
        str_url = sf_sync_config['sf_url'] + self.crea_url
        objs_all = self.env['stock.move.line'].search([('id', '=', self.id), ('functional_tool_name_id', '!=', False)])
        tool_stock_list = []
        if objs_all:
            for item in objs_all:
                val = {
                    'id': item.id,
                    'name': item.functional_tool_name,
                    'code': item.code,
                    'rfid': item.rfid,
                    'tool_groups_name': item.tool_groups_id.name,
                    'reference': item.reference,
                    'barcode': item.lot_id.name,
                    'functional_tool_type_code': item.functional_tool_type_id.code,
                    'diameter': item.diameter,
                    'knife_tip_r_angle': item.knife_tip_r_angle,
                    'install_tool_time': item.install_tool_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'location_id': item.location_id.name,
                    'location_dest_name': item.location_dest_id.name,
                    'date': item.date.strftime('%Y-%m-%d %H:%M:%S'),
                    'qty_done': item.qty_done,
                }
                tool_stock_list.append(val)
            kw = json.dumps(tool_stock_list, ensure_ascii=False)
            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
            ret = r.json()
            if ret.get('code') == 200:
                return "功能刀具出入库记录注册成功"
        else:
            raise UserError("没有注册功能刀具出入库记录信息")

    @api.model_create_multi
    def create(self, vals_list):
        records = super(StockMoveLine, self).create(vals_list)
        for record in records:
            if record.functional_tool_name_id:
                record.enroll_functional_tool_move()
        return records


class RealTimeDistributionFunctionalTools(models.Model):
    _inherit = 'sf.real.time.distribution.of.functional.tools'
    _description = '功能刀具安全库存注册'

    crea_url = "/api/functional_tool_distribution/create"

    # 注册同步功能刀具预警
    def enroll_functional_tool_real_time_distribution(self):
        sf_sync_config = self.env['res.config.settings'].get_values()
        token = sf_sync_config['token']
        sf_secret_key = sf_sync_config['sf_secret_key']
        headers = Common.get_headers(self, token, sf_secret_key)
        str_url = sf_sync_config['sf_url'] + self.crea_url
        objs_all = self.env['sf.real.time.distribution.of.functional.tools'].search([('id', '=', self.id)])
        tool_distribution_list = []
        if objs_all:
            for item in objs_all:
                functional_tool_codes = []
                for obj in item.sf_functional_cutting_tool_entity_ids:
                    functional_tool_codes.append(obj.code)
                val = {
                    'id': item.id,
                    'name': item.name,
                    'tool_groups_name': item.tool_groups_id.name,
                    'cutting_tool_type_code': item.sf_cutting_tool_type_id.code,
                    'diameter': item.diameter,
                    'knife_tip_r_angle': item.knife_tip_r_angle,
                    'tool_stock_num': item.tool_stock_num,
                    'side_shelf_num': item.side_shelf_num,
                    'on_tool_stock_num': item.on_tool_stock_num,
                    'tool_stock_total': item.tool_stock_total,
                    'min_stock_num': item.min_stock_num,
                    'max_stock_num': item.max_stock_num,
                    'batch_replenishment_num': item.batch_replenishment_num,
                    'unit': item.unit,
                    'image': '' if not item.image else base64.b64encode(item.image).decode('utf-8'),
                    'functional_tool_codes': str(functional_tool_codes),
                    'coarse_middle_thin': item.coarse_middle_thin,
                    'whether_standard_knife': item.whether_standard_knife,
                    'suitable_machining_method_names': get_suitable_machining_method_names(item),
                    'blade_tip_characteristics_name': item.blade_tip_characteristics_id.name,
                    'handle_type_name': item.handle_type_id.name,
                    'cutting_direction_names': get_cutting_direction_names(item),
                    'suitable_coolant_names': get_suitable_coolant_names(item),
                    'active': item.active
                }
                tool_distribution_list.append(val)
            kw = json.dumps(tool_distribution_list, ensure_ascii=False)
            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
            ret = r.json()
            if ret.get('code') == 200:
                return "功能刀具出入库记录注册成功"
        else:
            raise UserError("没有注册功能刀具出入库记录信息")

    @api.model_create_multi
    def create(self, vals_list):
        records = super(RealTimeDistributionFunctionalTools, self).create(vals_list)
        for record in records:
            if record:
                record.enroll_functional_tool_real_time_distribution()
        return records

    def write(self, vals):
        res = super().write(vals)
        if vals.get('sf_functional_cutting_tool_entity_ids') or vals.get('min_stock_num') or vals.get('max_stock_num'):
            self.enroll_functional_tool_real_time_distribution()
        return res