# -*- coding: utf-8 -*-

from odoo import models, fields, api, _
from odoo.tools.safe_eval import safe_eval
from odoo.tools.misc import frozendict
from odoo.exceptions import UserError
from datetime import datetime, date, time, timedelta
from odoo.exceptions import UserError, ValidationError
from lxml import etree
import logging
import ast

_logger = logging.getLogger(__name__)


class SoongWorkflowMixin(models.AbstractModel):
    _name = "soong.workflow.mixin"
    _description = "Soong Workflow Mixin"

    def read(self, fields=None, load='_classic_read'):
        if self.log_ids:
            if self.log_ids[-1].done_by.id == self.env.user.id and self.log_ids[-1].approval_state == '0':
                self.log_ids[-1].write({'approval_state': '1'})
        return super(SoongWorkflowMixin, self).read(fields=fields, load=load)

    # @api.model
    # def write(self, vals):
    #     res = super(SoongWorkflowMixin, self).write(vals)
    #     workflow_records = self.env['soong.workflow.record'].search([('name', '=', self.name)])
    #     for record in workflow_records:
    #         for field, value in vals.items():
    #             if hasattr(record, field):
    #                 setattr(record, field, value)
    #     return res

    @api.model
    def _compute_default_state(self):
        # Objects
        wkf_obj = self.env["soong.workflow"]
        rec_model = self._name
        # Get Flow Start
        wkf_recs = wkf_obj.search([("model_id", "=", rec_model), ('is_enable', '=', True)])
        for wkf_rec in wkf_recs:
            for node in wkf_rec.node_ids:
                if node.flow_start:
                    return node.node_name

    @api.model
    def _load_state(self):
        # Objects
        wkf_obj = self.env["soong.workflow"]
        # Variables
        rec_model = self._name
        ret = []
        # Get Status
        wkf_recs = wkf_obj.search([("model_id", "=", rec_model), ('is_enable', '=', True)])
        for rec in wkf_recs:
            for node in rec.node_ids:
                ret.append((node.node_name, node.name))
        return ret

    state = fields.Selection(
        selection="_load_state",
        string="Status",
        default=_compute_default_state,
        track_visibility="onchange",
        store=True
    )
    workflow_id = fields.Many2one(
        comodel_name="soong.workflow",
        string="Workflow Ref.",
        compute="_compute_workflow_id",
    )
    approval_users_ids = fields.One2many("soong.approval.users", "res_id",
                                         domain=lambda self: [('res_model', '=', self._name)], auto_join=True,
                                         string="审批明细")
    approval_sign_ids = fields.Many2many('res.users', store=False, compute="_compute_approval_sign_ids", string="加签人员")

    @api.depends("node_id", "log_ids")
    def _compute_approval_sign_ids(self):
        for record in self:
            record.approval_sign_ids = record.log_ids.filtered(lambda r: r.node_btn_name == "2" and r.node_id == record.node_id).done_by.ids

    @api.depends("state")
    def _compute_workflow_id(self):
        # Objects
        wkf_obj = self.env["soong.workflow"]
        for rec in self:
            # Variables
            rec_model = rec._name
            # Get Workflow
            rec.workflow_id = wkf_obj.search([("model_id", "=", rec_model), ('is_enable', '=', True)])

    node_id = fields.Many2one(
        comodel_name="soong.workflow.node",
        string="Workflow Node Ref.",
        compute="_compute_node_id",
    )

    @api.depends("state")
    def _compute_node_id(self):
        # Objects
        wkf_obj = self.env["soong.workflow"]
        for rec in self:
            # Variables
            rec_model = rec._name
            # Get Workflow Node
            rec.node_id = wkf_obj.search(
                [("model_id", "=", rec_model), ('is_enable', '=', True)]
            ).node_ids.filtered(lambda n: n.node_name == rec.state)

    log_ids = fields.One2many(comodel_name="soong.workflow.log", inverse_name="res_id", string=" ",
                              domain=lambda self: [("model", "=", self._name)], auto_join=True)
    log_ids2 = fields.One2many(comodel_name="soong.workflow.log2", inverse_name="res_id", string=" ",
                              domain=lambda self: [("model", "=", self._name)], auto_join=True)
    soong_record_ids = fields.One2many(comodel_name="soong.workflow.line", inverse_name="res_id", string=" ",)
    project_ids = fields.One2many(comodel_name="project.project.line", inverse_name="res_id", string=" ",)

    @api.model_create_multi
    def create(self, vals_list):
        res = super().create(vals_list)
        target_role = self.env['soong.user.role'].search(
            [('name', '=', '考勤校对'), ('company_id', '=', res.env.user.employee_id.company_id.id)],
            limit=1
        )
        target_role_id = target_role.id if target_role else None

        for record in res:
            button_ids = record.sudo().workflow_id.node_ids.button_ids.search(
                [('workflow_id', '=', record.workflow_id.id)])
            # 获取当前用户的主角色和辅助角色ID列表
            employee = record.env.user.employee_id
            current_user_role_ids = []
            if employee.user_role_id:
                current_user_role_ids.append(employee.user_role_id.id)
            if employee.user_role_ids:
                current_user_role_ids.extend(employee.user_role_ids.ids)
            if target_role_id in current_user_role_ids:
                continue
            for button_id in button_ids:
                if button_id.node_id.is_end:
                    continue
                allowed_departments = button_id.node_id.department_id
                if allowed_departments and employee.department_id.id not in allowed_departments.ids:
                    continue
                allowed_role_ids = []
                if button_id.users_role_id:
                    allowed_role_ids.append(button_id.users_role_id.id)
                elif button_id.users_role_group_ids:
                    allowed_role_ids.extend(button_id.users_role_group_ids.user_role_ids.ids)
                else:
                    continue
                if current_user_role_ids and any(role_id in allowed_role_ids for role_id in current_user_role_ids):
                    record.state = button_id.node_id.node_name
        return res

    def _create_update_logs(self, btn_rec):
        log_obj = self.env["soong.workflow.log"]
        if btn_rec.name not in ['转交', '加签', '加签确认', '退回', '收回', '结束']:
            record_obj = log_obj.search(
                [("model", "=", self._name),
                    ("res_id", "=", self.id),
                    ("node_id", "=", btn_rec.node_id.id),
                    ("workflow_id", "=", btn_rec.workflow_id.id),
                    ("node_btn_id", "=", btn_rec.id),
                    ("node_btn_name", "=", "0")
                 ], order="lase_click_date DESC", limit=1)
            if not record_obj:
                record_obj = log_obj.create({
                        "model": self._name,
                        "res_id": self.id,
                        "node_id": btn_rec.node_id.id,
                        "workflow_id": btn_rec.workflow_id.id,
                        "node_btn_id": btn_rec.id,
                        "done_by": self.env.uid,
                        "node_btn_name": "0",
                        "lase_click_date": fields.Datetime.now(),
                    })
            record_obj.write({"node_btn_id": btn_rec.id, "done_by": self.env.uid, "approval_state": "2"})
        record_obj = log_obj.search([
                ("model", "=", self._name),
                ("res_id", "=", self.id),
                ("node_id", "=", btn_rec.node_id.id),
                ("workflow_id", "=", btn_rec.workflow_id.id),
            ], order="lase_click_date DESC", limit=1
        )
        return record_obj

    def btn_exec_action(self):
        """
        Got invoked when a workflow button is called.
        :return: button action return value.
        """
        self.ensure_one()
        # Variables
        cx = self.env.context.copy() or {}
        cx.update({"active_id": self.id, "active_ids": self.ids})
        wkf_btn_obj = self.env["soong.workflow.node.button"]
        btn_rec = wkf_btn_obj.search([("btn_key", "=", cx.get("btn_key", False))])
        # 优化弹窗
        if btn_rec:
            log_obj = self._create_update_logs(btn_rec)
            # 判断加签
            if btn_rec.name in ["加签"]:
                # 弹窗 进行填写 人员
                wizard = self.env.ref("soong_workflow.view_soong_workflow_apostille_wizard")
                return {
                    "name": _("添加加签人员"),
                    "type": "ir.actions.act_window",
                    "view_mode": "form",
                    "res_model": "soong.workflow.apostille.wizard",
                    "views": [(wizard.id, "form")],
                    "view_id": wizard.id,
                    "target": "new",
                    "context": {
                        "default_res_id": self.id,
                        "default_res_model": self._name,
                        "default_log_ids": log_obj.ids,
                        "default_node_btn_id": btn_rec.id,
                    },
                }
            if btn_rec.name in ["加签确认"]:
                # 弹窗 进行填写 人员
                wizard = self.env.ref("soong_workflow.view_soong_workflow_apostille_ok_wizard")
                return {
                    "name": _("添加加签人员"),
                    "type": "ir.actions.act_window",
                    "view_mode": "form",
                    "res_model": "soong.workflow.apostille.ok.wizard",
                    "views": [(wizard.id, "form")],
                    "view_id": wizard.id,
                    "target": "new",
                    "context": {
                        "default_res_id": self.id,
                        "default_res_model": self._name,
                        "default_log_ids": log_obj.ids,
                        "default_node_btn_id": btn_rec.id,
                    },
                }
            if btn_rec.name not in ["加签", "加签确认"]:
                # 判断当前是否所有加签都已经结束
                apostille_log_obj = self.sudo().env["soong.workflow.log"].search(
                    [
                        ("model", "=", self._name),
                        ("res_id", "=", self.id),
                        ("node_id", "=", btn_rec.node_id.id),
                        ("workflow_id", "=", btn_rec.workflow_id.id),
                        ("node_btn_name", "=", "2"),
                        ("approval_state", "!=", "2")
                    ]
                )
                if apostille_log_obj:
                    raise UserError("当前加签人员还有没有审批完成的！")
            # 继续正常流程
            if btn_rec.has_comment:
                return self.with_context(cx)._add_comment(log_obj, btn_rec)
            if btn_rec.name == '收回':
                return {
                    'name': '收回弹窗',
                    'type': 'ir.actions.act_window',
                    'view_mode': 'form',
                    'res_model': 'soong.bounced.wizard',
                    "target": "new",
                    'context': {
                        'default_res_id': self.id,
                        "default_res_model": self._name,
                    }
                }
            else:
                return btn_rec.with_context(cx).run()

    def _add_comment(self, logs, btn_rec):
        trans_link_ids = []
        wizard = self.env.ref("soong_workflow.view_soong_workflow_comment_wizard")
        # 状态列表
        state_list = [i.node_name for i in btn_rec.workflow_id.node_ids.sorted('sequence')]
        # 当前节点状态
        self_state = state_list.index(self.state)
        self.env['trans.link'].search([]).unlink()
        # 退回节点根据日志进行判断
        if btn_rec.name == '退回':
            for ret in self.log_ids.search([('approval_state', '=', '2'), ('res_id', '=', self.id), ('node_btn_name', '=', '0')]):
                if not self.env['trans.link'].search([('name', '=', ret.name)]):
                    self.env['trans.link'].create({
                        'node_button_id': btn_rec.id,
                        'name': ret.name,
                        'link_type': 'return',
                        'record_id': self.id,
                    })
        if btn_rec.name == '转交':
            skipped_node_names = [] # 因没有可用按钮而跳过的节点
            node_list = list(btn_rec.workflow_id.node_ids.sorted('sequence'))
            index = self_state
            actual_path_nodes = []

            #跟踪整个工作流路径，只保留实际会执行的节点
            while index < len(node_list):
                current_node = node_list[index]
                actual_path_nodes.append(current_node)
                if not current_node.out_link_ids:
                    index = 20  # 防止死循环
                    break
                current_department = self.department_id
                if len(current_node.out_link_ids) > 1:
                    # 筛选与当前节点部门匹配的后续节点
                    valid_nodes = []
                    for link in current_node.out_link_ids:
                        target_node = link.node_to
                        # 如果目标节点有部门限制，且与当前节点部门匹配
                        if target_node.department_id and any(
                                dept in current_department or
                                current_department in self.get_all_sub_departments(dept)
                                for dept in target_node.department_id
                        ):
                            valid_nodes.append((target_node, link))

                    # 尝试父部门匹配
                    if not valid_nodes and current_department and current_department.parent_id:
                        parent_department = current_department.parent_id
                        for link in current_node.out_link_ids:
                            target_node = link.node_to
                            if target_node.department_id and any(
                                    dept in parent_department or
                                    parent_department in self.get_all_sub_departments(dept)
                                    for dept in target_node.department_id
                            ):
                                valid_nodes.append((target_node, link))

                    # 如果两种匹配都失败，将所有节点加入有效列表
                    if not valid_nodes:
                        for link in current_node.out_link_ids:
                            valid_nodes.append((link.node_to, link))

                    # 选择第一个匹配的节点
                    next_node, matched_link = valid_nodes[0]
                    matched_key = next_node.name
                else:
                    matched_link = current_node.out_link_ids[0]
                    next_node = matched_link.node_to
                    matched_key = next_node.name
                    transfer_buttons = [
                        btn for btn in next_node.button_ids
                        if btn.name == '转交'
                    ]
                    end_buttons = [
                        btn for btn in next_node.button_ids
                        if btn.name == '结束'
                    ]
                    has_visible_transfer_btn = True
                    for btn in transfer_buttons:
                        if btn.is_review_invisible:
                            domain = eval(btn.invisible_expression)
                            expression_result = self.search(domain)
                            has_self_in_result = self.id in expression_result.ids
                            if not end_buttons:
                                if has_self_in_result:
                                    has_visible_transfer_btn = True
                                    break
                                else:
                                    has_visible_transfer_btn = False
                            else:
                                has_visible_transfer_btn = True
                        else:
                            has_visible_transfer_btn = True

                    if not has_visible_transfer_btn:
                        skipped_node_names.append(next_node.name)
                        _logger.info(f"跳过节点: {next_node.name}，无可见的转交按钮")

                # 更新索引
                index = state_list.index(matched_key)
                if index >= len(node_list):
                    break

            #根据实际路径创建trans.link记录并生成domain
            actual_path_links = []
            for node in actual_path_nodes[1:]:
                if node.name not in skipped_node_names:
                    link = self.env['trans.link'].create({
                        'node_button_id': btn_rec.id,
                        'name': node.name,
                        'link_type': 'trans',
                        'record_id': self.id,
                    })
                    actual_path_links.append(link)

            if actual_path_links:
                trans_link_ids = [link.id for link in actual_path_links]
                trans_domain = [('id', 'in', trans_link_ids)]
            else:
                trans_domain = []

        is_supervising = False
        if self._module in ['yuthon_official']:
            is_supervising = self.is_supervising

        return {
            "name": _("评论"),
            "type": "ir.actions.act_window",
            "view_mode": "form",
            "res_model": "soong.workflow.comment.wizard",
            "views": [(wizard.id, "form")],
            "view_id": wizard.id,
            "target": "new",
            "context": {
                "default_res_id": self.id,
                "default_code": self.code,
                "default_res_model": self._name,
                "default_log_ids": logs.ids,
                "default_node_btn_id": btn_rec.id,
                "default_is_supervising": is_supervising,
                "default_trans_link_id": self.env['trans.link'].search(trans_domain, limit=1).id if btn_rec.name == '转交' else False,
                "all_workflow_links": trans_link_ids,
                "default_return_link_id": self.env['trans.link'].search(
                    [('link_type', '=', 'return'), ('record_id', '=', self.id)],
                    limit=1).id if btn_rec.name == '退回' else False,
            },
        }

    def get_all_sub_departments(self, department, level=0, print_tree=True):
        all_departments = department.child_ids

        # 打印当前部门的子部门
        if print_tree and department.child_ids:
            indent = "  " * level  # 使用空格缩进表示层级
            print(f"{indent}{department.name} 的子部门:")

            for child in department.child_ids:
                child_indent = "  " * (level + 1)
                print(f"{child_indent}- {child.name} (ID: {child.id})")

        # 递归获取每个子部门的子部门
        for child in department.child_ids:
            child_sub_departments = self.get_all_sub_departments(child, level + 1, print_tree)
            all_departments |= child_sub_departments

        return all_departments

    @api.constrains("state")
    def _update_wkf_records(self):
        for rec in self:
            record_obj = self.env["soong.workflow.record"].search([("res_model", "=", rec._name), ("res_id", "=", rec.id)])
            record_id = self.env[rec._name].search([('id', '=', rec.id)])
            current_user_id = self.env.user.id
            if self.state in ['申请人', '拟办', '草稿']:
                if not record_obj:
                    values = {
                        "code": record_id.code,
                        "res_model": rec._name,
                        "department_id": rec.department_id.id,
                        "res_id": rec.id,
                        "workflow_id": rec.workflow_id.id,
                        "node_id": rec.node_id.id,
                        "done_by": self.env.uid,
                        "users_ids": [(4, current_user_id)],
                        "employee_ids": self.env.user.employee_id,
                        "write_date2": fields.Datetime.now(),
                    }
                    # 查找匹配的字段
                    matched_fields = self.find_fields_by_string(record_id)
                    # 提取"事由"或"正文"字段的值
                    text_fields = [f for f in matched_fields if
                                   '事由' in f['field_string'] or '正文' in f['field_string']]
                    if text_fields:
                        # 优先使用"事由"字段，没有则使用第一个"正文"字段
                        reason_field = next((f for f in text_fields if '事由' in f['field_string']), text_fields[0])
                        values["text"] = getattr(rec, reason_field['field_name'], '')

                    # 提取"附件"字段的值
                    attachment_fields = [f for f in matched_fields if '附件' in f['field_string']]
                    if attachment_fields and attachment_fields[0]['field_type'] in ['many2many', 'one2many']:
                        # 处理附件关系字段
                        attachment_field = attachment_fields[0]
                        attachment_ids = getattr(rec, attachment_field['field_name'], [])
                        if attachment_ids:
                            values["documents_ids"] = [(6, 0, attachment_ids.ids)]
                    # 创建工作流记录
                    self.env["soong.workflow.record"].create(values)

            if record_obj:
                record_obj.update({"workflow_id": rec.workflow_id.id,
                                   "node_id": rec.node_id.id,
                                   "done_by": self.env.uid,
                                   "write_date2": fields.Datetime.now(),
                                   })

    def find_fields_by_string(self,record_id):
        """
        根据模型名称和记录ID查找字段，其string属性包含特定关键词
        :param record_id: 记录id
        :return: 匹配的字段信息列表
        """
        # 定义要查找的关键词
        keywords = ['正文', '事由', '附件']
        # 获取模型的所有字段
        fields = record_id.fields_get()
        # 存储匹配的字段信息
        matched_fields = []
        # 遍历所有字段，检查string属性
        for field_name, field_attrs in fields.items():
            field_string = field_attrs.get('string', '')
            # 检查字段的string是否包含任何关键词
            if any(keyword in field_string for keyword in keywords):
                matched_fields.append({
                    'field_name': field_name,
                    'field_string': field_string,
                    'field_type': field_attrs.get('type'),
                })
        return matched_fields

    def unlink(self):
        self.mapped("log_ids").unlink()
        self.mapped("log_ids2").unlink()
        if self.env.user.name != 'Administrator':
            if len(self.log_ids) > 1:
                raise UserError("该流程不允许删除，如果要调整请联系管理员")
        record_objs = self.env["soong.workflow.record"].search([("res_model", "=", self._name), ("res_id", "in", self.ids)])
        record_objs.unlink()
        return super(SoongWorkflowMixin, self).unlink()

    def action_open_diagram(self):
        self.ensure_one()
        current_node_id = self.workflow_id.node_ids.filtered(
            lambda n: n.node_name == self.state
        )
        highlight_color = self.workflow_id.current_stage_highlight_color

        return {
            "name": _("Workflow: %(name)s")
                    % {
                        "name": self.display_name,
                    },
            "res_model": "soong.workflow",
            "type": "ir.actions.act_window",
            "res_id": self.workflow_id.id,
            "context": {
                "highlight_node_id": current_node_id.id,
                "highlight_node_color": highlight_color,
                "diagram_readonly": True,
            },
            "views": [(False, "diagram_plus")],
        }

    @api.model
    def get_view(self, view_id=None, view_type="form", **options):
        res = super().get_view(view_id, view_type, **options)
        active_id = self._context.get('active_id')
        if '<form create="false"' not in res['arch']:
            if view_type in ["tree", "form"]:
                params = {}
                if "field" in res["arch"]:
                    res = self._remove_default_header(view_type, res)
                    # res = self._remove_default_modifiers(view_type, res)
                    res = self._load_buttons_view(view_type, res)
                    res = self._load_button_box_view(view_type, res)
                    res = self._load_state_view(view_type, res)
                    # res = self._load_one2many_views(view_type, res)
                    res = self._update_fields_view(view_type, res)
                    # res = self._add_state_tree_view(view_type, res)
                    if self.env.user.has_group("soong_workflow.group_soong_workflow_manager"):
                        res = self._add_soong_workflow_log_manager(view_type, res, params)
                    else:
                        res = self._add_soong_workflow_log(view_type, res, params)
                    res = self._load_sign_view(view_type, res)
                    # res = self._load_workflow_approver_view(view_type, res)
        return res

    # 收回
    def action_withdraw(self):
        pass

    def _remove_default_header(self, view_type, res):
        """
        Removes default header element from form view.
        :param view_type: Type of view now rendering.
        :param res: View resource data.
        :return: Updated view resource.
        """
        model = self._name
        wkf_obj = self.env["soong.workflow"]
        wkf_rec = wkf_obj.search([("model_id", "=", model), ('is_enable', '=', True)])

        if not wkf_rec.remove_default_btn_until_end:
            return res
        # Variables
        arch = etree.fromstring(res["arch"])
        # Find Default Header Element & EDIT it
        if view_type == "form":
            header_el = arch.xpath("//form/header")
            header_el = header_el[0] if header_el else False
            if header_el:
                for button in header_el.iter("button"):
                    btn_invisible = "state != 'end'"
                    if "invisible" in button.attrib:
                        btn_invisible = btn_invisible + " or " + button.attrib["invisible"]
                    button.set("invisible", btn_invisible)
        res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _remove_default_modifiers(self, view_type, res):
        """
        Removed fields default modifiers & attributes in form view.
        :param view_type: Type of view now rendering.
        :param res: View resource data.
        :return: Updated view resource.
        """
        # Variables
        model = self._name
        wkf_obj = self.env["soong.workflow"]
        wkf_rec = wkf_obj.search([("model_id", "=", model), ('is_enable', '=', True)])
        arch = etree.fromstring(res["arch"])

        # Validation
        if not wkf_rec.remove_default_attrs_mod:
            return res
        fields_name = wkf_rec.node_ids.field_ids.name.mapped("name")
        # Find Field & Remove Modifiers
        if view_type == "form":
            for field in arch.iter("field"):
                field_name = field.attrib.get("name", False)
                if not field_name or field_name not in fields_name:
                    continue
                for attr in field.attrib.keys():
                    if attr != "name":
                        field.attrib.pop(attr)
        res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _load_buttons_view(self, view_type, res):
        """
        Adds buttons to state bar in form view.
        :param view_type: Type of view now rendering.
        :param res: View resource data.
        :return: Updated view resource.
        """
        # Variables
        this = self
        model = self._name
        wkf_obj = self.env["soong.workflow"]
        arch = etree.fromstring(res["arch"])

        # Helper Functions
        def _check_condition_code(btn):
            locals_dict = {
                "env": this.env,
                "model": this.env[model],
                "obj": None,
                "user": this.env["res.users"].browse(this.env.uid),
                "datetime": datetime,
                "time": time,
                "date": date,
                "timedelta": timedelta,
                "workflow": this.env["soong.workflow"],
                "warning": this.warning,
                "syslog": this.syslog,
            }
            try:
                safe_eval(
                    btn.reviewer_expression,
                    locals_dict=locals_dict,
                    mode="exec",
                    nocopy=True,
                )
                user = "user" in locals_dict and locals_dict["user"] or False
                if user and self.env.user in user:
                    return True
                return False
            except Warning as ex:
                raise ex
            except:
                raise UserError(_("Wrong python condition defined."))

        # Find header & ADD button
        if view_type == "form":
            # Get Some Elements
            form_el = arch.xpath("//form")
            form_el = form_el[0] if form_el else False
            header_el = arch.xpath("//form/header")
            header_el = header_el[0] if header_el else False
            # Create Header Element If not Exists
            if header_el is False:
                header_el = etree.Element("header")
                form_el.insert(0, header_el)
            # Construct Buttons & Fields Tags
            wkf_rec = wkf_obj.search([("model_id", "=", model), ('is_enable', '=', True)])
            for node in wkf_rec.node_ids:
                for button in node.button_ids:
                    if self.env.user.has_group("soong_workflow.group_soong_workflow_manager"):
                        btn_exec_action_el = etree.SubElement(header_el, "button")
                        btn_exec_action_el.set("name", "btn_exec_action")
                        btn_exec_action_el.set("string", button.name)
                        btn_exec_action_el.set("type", "object")
                        if button.is_highlight:
                            btn_exec_action_el.set("class", "oe_highlight")
                        if button.has_icon:
                            btn_exec_action_el.set("icon", button.icon)
                        btn_exec_action_el.set("invisible", "state != '%s'" % node.node_name)
                        btn_exec_action_el.set("context", "{'btn_key':'%s','active_model':'%s'}" % (button.btn_key, self._name),)
                    else:
                        is_apostille = False
                        if button.btn_hide:
                            if button.review_type == "individual":
                                if self.env.user != button.reviewer_id:
                                    continue
                            elif button.review_type == "group":
                                if self.env.user not in button.reviewer_group_id.users:
                                    continue
                            # 如果是加签确认
                            elif button.review_type == "apostille":
                                is_apostille = True
                            elif button.review_type == "expression":
                                if not _check_condition_code(button):
                                    continue
                            # 如果是收回
                            elif button.review_type == "withdraw":
                                # 如果当前正在审批中或者审批完成的禁止收回
                                if self.sudo().env["soong.workflow.log"].search([("workflow_id", "=", wkf_rec.id), ("node_id", "=", node.id), ("approval_state", "in", ["1", "2", "3"])]):
                                    continue
                        # Add Button to View
                        btn_exec_action_el = etree.SubElement(header_el, "button")
                        btn_exec_action_el.set("name", "btn_exec_action")
                        btn_exec_action_el.set("string", button.name)
                        btn_exec_action_el.set("type", "object")

                        id_el = etree.Element("field")
                        id_el.set("name", "id")
                        id_el.set("invisible", "1")

                        if button.is_highlight:
                            btn_exec_action_el.set("class", "oe_highlight")
                        if button.has_icon:
                            btn_exec_action_el.set("icon", button.icon)
                        # 接下来是隐藏的配置
                        invisible = "not id or state != '{0}' ".format(str(node.node_name))
                        if button.review_type == 'user_role':
                            # 构建角色条件
                            role_domain = []
                            if button.users_role_id:
                                role_domain = [
                                    '|',
                                    ('employee_id.user_role_id', '=', button.users_role_id.id),
                                    ('employee_id.user_role_ids', 'in', button.users_role_id.id)
                                ]
                            if button.users_role_group_ids:
                                role_ids = button.users_role_group_ids.user_role_ids.ids
                                role_domain = [
                                    '|',
                                    ('employee_id.user_role_id', 'in', role_ids),
                                    ('employee_id.user_role_ids', 'in', role_ids)
                                ]
                            # 如果有角色条件，添加到可见性条件中
                            if role_domain:
                                allowed_user_ids = self.env['res.users'].search(role_domain).ids
                                invisible += f" or uid not in {allowed_user_ids}"
                        # 如果有隐藏条件的话，启用隐藏
                        if button.is_review_invisible and button.invisible_expression:
                            domain = eval(button.invisible_expression)
                            btn_invisible = self.sudo().env[button.workflow_id.model_id.model].search(domain).ids
                            invisible += " or id not in {0} ".format(str(btn_invisible))
                        # 如果是加签确认
                        if is_apostille:
                            id_el = etree.Element("field")
                            id_el.set("name", "approval_sign_ids")
                            id_el.set("invisible", "1")
                            invisible += " or uid not in approval_sign_ids"
                        if button.name in ["退回", "结束", "收回"]:
                            id_el = etree.Element("field")
                            id_el.set("name", "log_ids")
                            id_el.set("invisible", "1")
                            invisible += " or not log_ids "
                        # if button.name == "结束":
                        #    invisible += " or True"
                        invisible += " or work_end"
                        btn_exec_action_el.set("invisible", invisible)
                        btn_exec_action_el.set("context", "{'btn_key':'%s','active_model':'%s'}" % (button.btn_key, self._name),)
            res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _load_button_box_view(self, view_type, res):
        """
        Adds button_box in form view.
        :param view_type: Type of view now rendering.
        :param res: View resource data.
        :return: Updated view resource.
        """
        arch = etree.fromstring(res["arch"])

        # Find header & ADD button
        if view_type == "form":
            # Get Some Elements
            form_sheet_el = arch.xpath("//form/sheet")
            form_sheet_el = form_sheet_el[0] if form_sheet_el else False
            button_box_el = arch.xpath("//form/sheet/div[hasclass('oe_button_box')]")
            button_box_el = button_box_el[0] if button_box_el else False
            # Create button_box Element If not Exists
            if button_box_el is False:
                button_box_el = etree.Element("div")
                button_box_el.set("class", "oe_button_box")
                button_box_el.set("name", "button_box")
                if form_sheet_el:
                    form_sheet_el.insert(0, button_box_el)
            # Add Button to View
            btn_exec_action_el = etree.SubElement(button_box_el, "button")
            btn_exec_action_el.set("name", "action_open_diagram")
            btn_exec_action_el.set("type", "object")
            btn_exec_action_el.set("string", _("View Flow"))
            btn_exec_action_el.set("class", "oe_stat_button")
            btn_exec_action_el.set("icon", "fa-code-fork")

            res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _load_state_view(self, view_type, res):
        """
        Adds state bar to form view.
        :param view_type: Type of view now rendering.
        :param res: View resource data.
        :return: Updated view resource.
        """
        # Variables
        wkf_obj = self.env["soong.workflow"]
        model = self._name
        visible_seq = []
        arch = etree.fromstring(res["arch"])
        wkf_rec = wkf_obj.search([("model_id", "=", model), ('is_enable', '=', True)])

        #  Find header & ADD state
        if view_type == "form":
            # Get Header Element
            header_el = arch.xpath("//form/header")
            header_el = header_el[0] if header_el else False
            # Create State Element If not Exists
            if header_el is not False:
                state_el = etree.Element("field")
                state_el.set("name", "state")
                state_el.set("widget", "statusbar")
                state_el.set("invisible", "1")
                # Loop all nodes
                for node in wkf_rec.node_ids:
                    # Read Visible States
                    if node.is_visible:
                        visible_seq.append(node.node_name)
                # Set Attributes & Setup Modifiers for State Field
                if visible_seq:
                    state_el.set("statusbar_visible", ",".join(visible_seq))
                header_el.append(state_el)
        res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _load_one2many_views(self, view_type, res):
        # Variables
        # wkf_obj = self.env["soong.workflow"]
        # model = self._name
        arch = etree.fromstring(res["arch"])
        # wkf_rec = wkf_obj.search([("model_id", "=", model)])

        if view_type == "form":
            # Locate the group element
            group_el = arch.xpath("//sheet")
            if group_el:
                group_el = group_el[0]
            else:
                # If no group element exists, create one and add it to the arch
                group_el = etree.Element("sheet")
                # Insert the group element at the beginning or end of the arch
                arch.insert(0, group_el)

            # Locate or create the notebook element within the group
            notebook_el = group_el.xpath(".//notebook")
            if notebook_el:
                notebook_el = notebook_el[0]
            else:
                # Create a notebook element if it doesn't exist
                notebook_el = etree.Element("notebook")
                group_el.append(notebook_el)

            # Create a new page element
            page_el = etree.Element("page")
            page_el.set("string", "审批明细")  # Set a label for the new page

            # Create the field element for the one2many field
            field_el = etree.Element("field")
            field_el.set("name", "approval_users_ids")
            field_el_context = {'tree_view_ref': 'soong_workflow.soong_approval_users_search',
                                'default_res_model_id': self.env['ir.model']._get(self._name).id}
            field_el.set("context", str(field_el_context))

            # Append the field element to the new page
            page_el.append(field_el)

            # Append the new page to the notebook
            notebook_el.append(page_el)

            # Convert the modified XML tree back to a string
        res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _load_sign_view(self, view_type, res):
        arch = etree.fromstring(res["arch"])
        if view_type == "form":
            sheet_el = arch.xpath("//sheet")
            if sheet_el:
                sheet_el = sheet_el[0]
            else:
                sheet_el = etree.Element("sheet")
                arch.insert(0, sheet_el)
            notebook_el = sheet_el.xpath(".//notebook")
            if notebook_el:
                notebook_el = notebook_el[0]
            else:
                notebook_el = etree.Element("notebook")
                sheet_el.append(notebook_el)
            page_el = etree.Element("page")
            page_el.set("string", "加签人员")  # 设置页面标签
            page_el.set("invisible", "1")  # todo domain
            field_m2m_el = etree.Element("field")
            field_m2m_el.set("name", "approval_sign_ids")
            field_m2m_el.set("widget", "many2many_tags")
            page_el.append(field_m2m_el)
            notebook_el.append(page_el)
        res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    # def _load_workflow_approver_view(self, view_type, res):
    #     arch = etree.fromstring(res["arch"])
    #     if view_type == "form":
    #         sheet_el = arch.xpath("//sheet")
    #         if sheet_el:
    #             sheet_el = sheet_el[0]
    #         else:
    #             sheet_el = etree.Element("sheet")
    #             arch.insert(0, sheet_el)
    #         notebook_el = sheet_el.xpath(".//notebook")
    #         if notebook_el:
    #             notebook_el = notebook_el[0]
    #         else:
    #             notebook_el = etree.Element("notebook")
    #             sheet_el.append(notebook_el)
    #         page_el = etree.Element("page")
    #         page_el.set("string", "审批流程")  # 设置页面标签
    #         page_el.set("invisible", "1")  # todo domain
    #         field_m2m_el = etree.Element("field")
    #         field_m2m_el.set("name", "workflow_approver_ids")
    #         page_el.append(field_m2m_el)
    #         notebook_el.append(page_el)
    #     res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
    #     return res

    def _update_fields_view(self, view_type, res):
        """
        Updates fields attributes.
        :param view_type: Type of view now rendering.
        :param res: View resource data.
        :return: Updated view resource.
        """
        # Objects
        wkf_obj = self.env["soong.workflow"]
        user_obj = self.env["res.users"]
        # Variables
        model = self._name
        uid = self._uid
        wkf_rec = wkf_obj.search([("model_id", "=", model), ('is_enable', '=', True)])
        arch = etree.fromstring(res["arch"])

        # Helper Functions
        def _get_external_id(group):
            arr = []
            ext_ids = group._get_external_ids()
            for ext_id in ext_ids:
                arr.append(ext_ids[ext_id][0])
            return arr

        if view_type == "form":
            # Read fields of view
            for field in arch.iter("field"):
                field_name = field.attrib.get("name", False)
                if not field_name:
                    continue
                # Get Fields Instance
                field_inst = arch.xpath("//field[@name='%s']" % str(field_name))
                field_inst = field_inst[0] if field_inst else False
                # Scope Variables
                readonly_arr = []
                required_arr = []
                invisible_arr = []
                if field_inst is not False:
                    # Loop all nodes
                    for node in wkf_rec.node_ids:
                        # Loop Other Nodes
                        for field_attrs in node.field_ids:
                            # Record all states for each attribute
                            if (
                                    field_inst is not False
                                    and field_attrs.name.name == field_inst.attrib["name"]
                            ):
                                flag_show = True
                                if field_attrs.name.name in ["code", "name_title"]:
                                    field_inst.set("readonly", "1")
                                    readonly_arr.append(node.node_name)
                                if field_attrs.readonly:
                                    readonly_arr.append(node.node_name)
                                if field_attrs.required:
                                    required_arr.append(node.node_name)
                                if field_attrs.invisible:
                                    invisible_arr.append(node.node_name)
                                # Check Users & Groups
                                if field_attrs.user_ids:
                                    user_rec = user_obj.browse(uid)
                                    if user_rec not in field_attrs.user_ids:
                                        flag_show = False
                                if field_attrs.group_ids:
                                    has_group = False
                                    user_rec = user_obj.browse(uid)
                                    ext_ids = _get_external_id(field_attrs.group_ids)
                                    for ext_id in ext_ids:
                                        has_group = user_rec.has_group(ext_id)
                                    if not has_group:
                                        flag_show = False
                                if not flag_show and (
                                        field_attrs.group_ids or field_attrs.user_ids
                                ):
                                    invisible_arr.append(node.node_name)
                        read_num = ''
                        if readonly_arr:
                            id_el = etree.Element("field")
                            id_el.set("name", "log_ids")
                            id_el.set("invisible", "1")
                            field_inst.set("readonly", "state in %s" % readonly_arr)
                    if required_arr:
                        field_inst.set("required", "state in %s" % required_arr)
                    if invisible_arr:
                        field_inst.set("invisible", "state in %s" % invisible_arr)
                    if self.env.user.has_group("soong_workflow.group_soong_workflow_manager"):
                        field_inst.set("readonly", "0")
                current_field_name = field_inst.attrib.get("name")
                if current_field_name in ["code", "name_title"]:
                    field_inst.set("readonly", "1")

        res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _add_state_tree_view(self, view_type, res):
        """
        Adds state field to tree view.
        :param view_type: Type of view now rendering.
        :param res: View resource data.
        :return: Updated view resource.
        """
        # Variables
        model = self._name
        model_obj = self.env[model]
        arch = etree.fromstring(res["arch"])

        # Add State Field to Tree View if not Exists
        if view_type == "tree":
            # Get Header Element
            tree_el = arch.xpath("//tree")
            tree_el = tree_el[0] if tree_el else False
            # Get State Element
            node_el = arch.xpath("//field[@name='node_id']")
            node_el = node_el[0] if node_el else False
            if node_el is False:
                node_el = etree.Element("field")
                node_el.set("name", "node_id")
                tree_el.append(node_el)
            approve_state_el = arch.xpath("//field[@name='approve_state']")
            approve_state_el = approve_state_el[0] if approve_state_el else False
            if approve_state_el is False:
                approve_state_el = etree.Element("field")
                approve_state_el.set("name", "approve_state")
                tree_el.append(approve_state_el)
            tree_el.set("decoration-muted", "approve_state == 'end'")
            tree_el.set("decoration-warning", "approve_state != 'end'")
        res["arch"] = etree.tostring(arch, encoding="unicode").replace("\t", "")
        return res

    def _add_soong_workflow_log_manager(self, view_type, res, params):
        View = self.env["ir.ui.view"]
        doc = etree.XML(res["arch"])
        all_models = res["models"].copy()
        for node in doc.xpath("/form/sheet"):
            # _add_tier_validation_reviews process
            str_element = self.env["ir.qweb"]._render("soong_workflow.soong_workflow_log_manager", params)
            new_node = etree.fromstring(str_element)
            new_arch, new_models = View.postprocess_and_fields(new_node, self._name)
            for model in new_models:
                if model in all_models:
                    continue
                if model not in res["models"]:
                    all_models[model] = new_models[model]
                else:
                    all_models[model] = res["models"][model]
            new_node = etree.fromstring(new_arch)
            node.append(new_node)
        res["arch"] = etree.tostring(doc)
        res["models"] = frozendict(all_models)
        return res

    def _add_soong_workflow_log(self, view_type, res, params):
        View = self.env["ir.ui.view"]
        doc = etree.XML(res["arch"])
        all_models = res["models"].copy()
        for node in doc.xpath("/form/sheet"):
            # _add_tier_validation_reviews process
            str_element = self.env["ir.qweb"]._render(
                "soong_workflow.soong_workflow_log", params
            )
            new_node = etree.fromstring(str_element)
            new_arch, new_models = View.postprocess_and_fields(new_node, self._name)
            for model in new_models:
                if model in all_models:
                    continue
                if model not in res["models"]:
                    all_models[model] = new_models[model]
                else:
                    all_models[model] = res["models"][model]
            new_node = etree.fromstring(new_arch)
            node.append(new_node)
        res["arch"] = etree.tostring(doc)
        res["models"] = frozendict(all_models)
        return res

    def warning(self, msg):
        if not isinstance(msg, str):
            msg = str(msg)
        raise UserError(msg)

    def syslog(self, msg):
        if not isinstance(msg, str):
            msg = str(msg)
        _logger.info(msg)

class SoongWorkflowLine(models.Model):
    _name = "soong.workflow.line"

    model = fields.Char(string="Related Document Model", index=True)
    res_id = fields.Integer(string="Related Document ID", index=True)
    workflow_record_id = fields.Many2one("soong.workflow.record", string="名称")
    code = fields.Char(related="workflow_record_id.code", string="流水号")
    approvals_group_id = fields.Many2one(related="workflow_record_id.approvals_group_id", string="审批组")
    create_uid = fields.Many2one(related="workflow_record_id.create_uid", string="创建人")
    write_date2 = fields.Datetime(related="workflow_record_id.write_date2", string="最后更新日期")


    def unlink(self):
        if not self.env.context.get('confirm_delete'):
            # 提示用户确认删除
            message = _("确定要删除这些记录吗？此操作不可撤销。")
            return {
                'name': _('确认删除'),
                'type': 'ir.actions.act_window',
                'view_mode': 'form',
                'res_model': 'workflow.line.wizard',
                'target': 'new',
                'context': {
                    'active_model': self._name,
                    'active_ids': self.ids,
                    'delete_message': message,
                }
            }
            # 继续执行删除操作
        return super(SoongWorkflowLine, self).unlink()
        # return {
        #     "type": "ir.actions.act_window",
        #     "name": "二次确认",
        #     "res_model": "workflow.line.wizard",
        #     "view_mode": "form",
        #     "target": "new",
        #     "context": {
        #         "default_workflow_id": self.workflow_record_id.id,
        #         "default_workflow_line_id": self.id
        #     },
        # }

    def open_record(self):
        return {
            "type": "ir.actions.act_window",
            "res_model": self.workflow_record_id.res_model,
            "res_id": self.workflow_record_id.res_id,
            "name": self.workflow_record_id.name,
            "view_mode": "form",
        }


class ProjectProjectLine(models.Model):
    _name = "project.project.line"

    model = fields.Char(string="Related Document Model", index=True)
    res_id = fields.Integer(string="Related Document ID", index=True)
    project_id = fields.Many2one("project.project", string="项目")
    user_id = fields.Many2one(related="project_id.user_id", string="项目管理员")
    date_start = fields.Date(related="project_id.date_start", string="日期")