from odoo import fields, models, api, _
from odoo.exceptions import UserError

class AccountPayment(models.Model):
    _inherit = 'account.payment'

    realization_id = fields.Many2one('hr.expense.realization', string='Originating Realization', readonly=True)

    def action_post(self):
        """
        Overriding to bypass hr_expense restriction and ensure deductions are synced.
        """
        # Identify payments that would normally be locked by hr_expense
        locked_payouts = self.filtered(lambda p: p.expense_sheet_id)
        if locked_payouts:
            # Store links to restore later
            links = {p.id: p.expense_sheet_id.id for p in locked_payouts}
            
            # 1. Hide the links in the cache so hr_expense's _synchronize_to_moves doesn't see them
            for p in locked_payouts:
                p.env.cache.set(p, p._fields['expense_sheet_id'], False)
            
            try:
                # 2. Force a sync with the 'amount' field to ensure deductions are redrawn
                for p in locked_payouts:
                    if p.state == 'draft':
                        p._synchronize_to_moves({'amount', 'deduction_line_ids', 'amount_substract'})
                
                # 3. Call the standard post logic while the link is hidden
                res = super().action_post()
                return res
            finally:
                # 4. Restore the links
                for p in locked_payouts:
                    if p.id in links:
                        p.env.cache.set(p, p._fields['expense_sheet_id'], self.env['hr.expense.sheet'].browse(links[p.id]))
        else:
            return super().action_post()

    def _synchronize_to_moves(self, changed_fields):
        # If deductions changed, we MUST include 'amount' to trigger Odoo's refresh
        if 'deduction_line_ids' in changed_fields or 'amount_substract' in changed_fields:
             changed_fields = set(changed_fields) | {'amount'}

        # Case for manual edits (write) when payment is draft
        draft_locked = self.filtered(lambda p: p.state == 'draft' and p.expense_sheet_id)
        if draft_locked:
            links = {p.id: p.expense_sheet_id.id for p in draft_locked}
            for p in draft_locked:
                p.env.cache.set(p, p._fields['expense_sheet_id'], False)
            try:
                return super()._synchronize_to_moves(changed_fields)
            finally:
                for p in draft_locked:
                    if p.id in links:
                        p.env.cache.set(p, p._fields['expense_sheet_id'], self.env['hr.expense.sheet'].browse(links[p.id]))
        
        return super()._synchronize_to_moves(changed_fields)

    def write(self, vals):
        # Standard Odoo write: if we are editing deductions, ensure bypass is used if needed
        # (Though _synchronize_to_moves override above should handle it)
        return super().write(vals)

    def action_cancel(self):
        res = super().action_cancel()
        for payment in self:
            if payment.expense_sheet_id:
                payment.expense_sheet_id.invalidate_recordset(['state'])
            if payment.realization_id and payment.realization_id.expense_sheet_id:
                payment.realization_id.expense_sheet_id.invalidate_recordset(['state'])
        return res

    def action_draft(self):
        res = super().action_draft()
        for payment in self:
            if payment.expense_sheet_id:
                payment.expense_sheet_id.invalidate_recordset(['state'])
            if payment.realization_id and payment.realization_id.expense_sheet_id:
                payment.realization_id.expense_sheet_id.invalidate_recordset(['state'])
        return res