# -*- coding: utf-8 -*-
from odoo import models, fields, api, _
from odoo.exceptions import UserError
import logging

_logger = logging.getLogger(__name__)


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

    def action_post(self):
        # 1. Capture info before super() because we might need to create extra moves
        centralized_payments = self.filtered(
            lambda p: p.journal_id.is_centralized and p.company_id != p.journal_id.parent_company_id
        )

        # 2. Validate centralized payments before posting
        for payment in centralized_payments:
            if not payment.journal_id.branch_intercompany_account_id:
                raise UserError(
                    _("Please configure the Branch Inter-company Account on journal %s") % payment.journal_id.name
                )

        # 3. Call super() to post the original payment(s)
        res = super().action_post()

        # 4. Handle Centralized entries in Parent
        for payment in centralized_payments:
            parent_company = payment.journal_id.parent_company_id
            parent_journal = payment.journal_id.parent_journal_id
            parent_rk_account = payment.journal_id.parent_intercompany_account_id

            _logger.info(
                "Centralized Payment for %s | Company: %s -> Parent: %s | Parent Journal: %s | RK: %s",
                payment.name, payment.company_id.name, parent_company.name,
                parent_journal.name, parent_rk_account.code
            )

            if not parent_journal or not parent_rk_account:
                raise UserError(
                    _("Please configure the Parent Journal and RK Account on journal %s") % payment.journal_id.name
                )

            # Create the mirroring entry in Parent
            # Debit: Parent RK (Receivable from Branch)
            # Credit: Bank
            parent_move = self.env['account.move'].with_company(parent_company).create({
                'move_type': 'entry',
                'date': payment.date,
                'company_id': parent_company.id,
                'journal_id': parent_journal.id,
                'ref': _("Centralized Payment: %s (%s)") % (payment.name, payment.company_id.name),
                'line_ids': [
                    (0, 0, {
                        'name': payment.ref or _("Centralized Payment: %s") % payment.name,
                        'account_id': parent_rk_account.id,
                        'debit': payment.amount,
                        'partner_id': payment.partner_id.id,
                        'company_id': parent_company.id,
                    }),
                    (0, 0, {
                        'name': payment.ref or _("Centralized Payment: %s") % payment.name,
                        'account_id': parent_journal.default_account_id.id,
                        'credit': payment.amount,
                        'partner_id': payment.partner_id.id,
                        'company_id': parent_company.id,
                    }),
                ]
            })
            parent_move.action_post()
            _logger.info("Parent Move Posted: %s", parent_move.name)

        return res

    def _prepare_move_line_default_vals(self, write_off_line_vals=None, force_balance=None):
        """
        Override to use the Branch RK account for the liquidity line
        when the payment is centralized.
        """
        res = super()._prepare_move_line_default_vals(write_off_line_vals, force_balance)
        if self.journal_id.is_centralized and self.company_id != self.journal_id.parent_company_id:
            # Update the account if it matches the journal's default (liquidity account).
            for line_vals in res:
                if line_vals.get('account_id') == self.journal_id.default_account_id.id:
                    line_vals['account_id'] = self.journal_id.branch_intercompany_account_id.id
        return res