# Part of Odoo. See LICENSE file for full copyright and licensing details.
from freezegun import freeze_time

from odoo import Command, fields
from odoo.exceptions import UserError
from odoo.tests import tagged, Form

from odoo.addons.account.tests.common import TestTaxCommon
from odoo.addons.analytic.tests.common import AnalyticCommon


@tagged('post_install_l10n', 'post_install', '-at_install')
class TestL10nAccountWithholdingTaxesFlows(TestTaxCommon, AnalyticCommon):

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        # Set the withholding account so that we don't have to worry about it.
        cls.company_data['company'].withholding_tax_base_account_id = cls.env['account.account'].create({
            'code': 'WITHB',
            'name': 'Withholding Tax Base Account',
            'reconcile': True,
            'account_type': 'asset_current',
        })
        # We create a sequence for the same reason, so that we can forget about it.
        cls.withholding_sequence = cls.env['ir.sequence'].create({
            'implementation': 'no_gap',
            'name': 'Withholding Sequence',
            'padding': 4,
            'number_increment': 1,
        })
        cls.foreign_currency = cls.setup_other_currency('EUR')
        cls.outstanding_account = cls.env['account.account'].create({
            'name': "Outstanding Payments",
            'code': 'OSTP420',
            'reconcile': False,  # On purpose for testing.
            'account_type': 'asset_current'
        })

    def test_no_withholding_tax_invoice_but_included_one_on_payment(self):
        """ Test a flow where not withholding tax is set on the invoice line, but one is added to the payment register. """
        invoice_tax = self.percent_tax(15)
        withholding_tax = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(invoice_tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        with Form(payment_register) as payment_register_form:
            payment_register_form.should_withhold_tax = True
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax
                line.base_amount = 1000.0

        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'base_amount': 1000.0,
            'amount': 10.0,
        }])
        self.assertRecordValues(payment_register, [{'withholding_net_amount': 1140.0}])

        payment = payment_register._create_payments()
        self.assertRecordValues(payment, [{
            'amount': 1150.0,
        }])
        self.assertRecordValues(payment.move_id.line_ids, [
            {'balance': 1140.0,     'tax_ids': []},
            {'balance': -1150.0,    'tax_ids': []},
            {'balance': 10.0,       'tax_ids': []},
            {'balance': 1000.0,     'tax_ids': []},
            {'balance': -1000.0,    'tax_ids': withholding_tax.ids},
        ])

    def test_withholding_tax_before_payment(self):
        """
        Post the invoice, then register withholding taxes.
        Afterward, register the payment separately.
        """
        invoice_tax = self.percent_tax(15)
        withholding_tax = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(invoice_tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        with Form(payment_register) as payment_register_form:
            payment_register_form.should_withhold_tax = True
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax
                line.base_amount = 1000.0
        self.assertRecordValues(payment_register, [{
            'amount': 1150.0,
            'withholding_net_amount': 1140.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'original_base_amount': 1000.0,
            'original_tax_amount': 10.0,
            'base_amount': 1000.0,
            'amount': 10.0,
        }])

        with Form(payment_register) as payment_register_form:
            payment_register_form.amount = 10
        self.assertRecordValues(payment_register, [{
            'amount': 10.0,
            'withholding_net_amount': 0.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'original_base_amount': 1000.0,
            'original_tax_amount': 10.0,
            'base_amount': 1000.0,
            'amount': 10.0,
        }])

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 0.0},
            # Receivable line:
            {'balance': -10.0},
            # withholding line:
            {'balance': 10.0},
            # base lines:
            {'balance': 1000.0},
            {'balance': -1000.0},
        ])

        # We then register payment a second time, only for the actual payment.
        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'amount': 1140.0,
            'withholding_net_amount': 1140.0,
        }])
        self.assertFalse(payment_register.withholding_line_ids)

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Receivable line:
            {'balance': 1140.0},
            # Liquidity line:
            {'balance': -1140.0},
        ])

    def test_withholding_tax_amounts_manipulation(self):
        """ Test manipulating the withholding tax amounts in various way, including using foreign currencies. """
        comp_curr = self.env.company.currency_id
        foreign_curr = self.foreign_currency

        invoice_tax = self.percent_tax(15)
        withholding_tax1 = self.percent_tax(
            amount=-1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
        )
        withholding_tax2 = self.percent_tax(
            amount=-2,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
        )

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'currency_id': foreign_curr.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'tax_ids': [Command.set((invoice_tax + withholding_tax1).ids)],
            })],
        })
        invoice.action_post()
        self.assertRecordValues(invoice, [{
            'amount_untaxed': 2000.0,
            'amount_tax': 300.0,
            'amount_total': 2300.0,
        }])

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'amount': 2300.0,
            'withholding_net_amount': 2280.0,
            'source_amount': 1150.0,
            'source_amount_currency': 2300.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'original_base_amount': 2000.0,
            'original_tax_amount': 20.0,
            'base_amount': 2000.0,
            'amount': 20.0,
        }])

        with Form(payment_register) as payment_register_form:
            # We need the custom user amount to be set for proper computation of comodel_percentage_paid_factor later on
            # when the currency changes
            payment_register_form.amount = 1150

        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'original_base_amount': 2000.0,
            'original_tax_amount': 20.0,
            'base_amount': 1000.0,
            'amount': 10.0,
        }])

        with Form(payment_register) as payment_register_form:
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax2
                line.base_amount = 500.0

        self.assertRecordValues(payment_register.withholding_line_ids, [
            {
                'original_base_amount': 2000.0,
                'original_tax_amount': 20.0,
                'base_amount': 1000.0,
                'amount': 10.0,
            },
            {
                'original_base_amount': 500.0,
                'original_tax_amount': 10.0,
                'base_amount': 500.0,
                'amount': 10.0,
            },
        ])

        with Form(payment_register) as payment_register_form:
            # Uses the form emulator as we mix custom amounts and currency changes, which is handled by a onchange
            payment_register_form.currency_id = comp_curr

        self.assertRecordValues(payment_register, [{
            'amount': 575.0,
            'withholding_net_amount': 560.0,
            'source_amount': 1150.0,
            'source_amount_currency': 2300.0,
        }])
        # The manual line amount is not updated from a currency change; this is a current limitation
        self.assertRecordValues(payment_register.withholding_line_ids, [{
                'original_base_amount': 1000.0,
                'original_tax_amount': 10.0,
                'base_amount': 500.0,
                'amount': 5.0,
            },
            {
                'original_base_amount': 500.0,
                'original_tax_amount': 10.0,
                'base_amount': 500.0,
                'amount': 10.0,
        }])

        with Form(payment_register) as payment_register_form:
            payment_register_form.currency_id = foreign_curr
            payment_register_form.amount = 230

        self.assertRecordValues(payment_register, [{
            'amount': 230.0,
            'withholding_net_amount': 218.0,
            'source_amount': 1150.0,
            'source_amount_currency': 2300.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
                'original_base_amount': 2000.0,
                'original_tax_amount': 20.0,
                'base_amount': 200.0,
                'amount': 2.0,
            },
            {
                'original_base_amount': 500.0,
                'original_tax_amount': 10.0,
                'base_amount': 500.0,
                'amount': 10.0,
        }])

        with Form(payment_register) as payment_register_form:
            with payment_register_form.withholding_line_ids.edit(0) as line:
                line.base_amount = 150.0
        self.assertRecordValues(payment_register.withholding_line_ids, [{
                'original_base_amount': 2000.0,
                'original_tax_amount': 20.0,
                'base_amount': 150.0,
                'amount': 1.5,
            },
            {
                'original_base_amount': 500.0,
                'original_tax_amount': 10.0,
                'base_amount': 500.0,
                'amount': 10.0,
        }])

        with Form(payment_register) as payment_register_form:
            with payment_register_form.withholding_line_ids.edit(0) as line:
                line.amount = 2.0
        self.assertRecordValues(payment_register, [{
            'amount': 230.0,
            'withholding_net_amount': 218.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
                'original_base_amount': 2000.0,
                'original_tax_amount': 20.0,
                'base_amount': 150.0,
                'amount': 2.0,
            },
            {
                'original_base_amount': 500.0,
                'original_tax_amount': 10.0,
                'base_amount': 500.0,
                'amount': 10.0,
        }])

        payment = payment_register._create_payments()
        self.assertRecordValues(payment, [{
            'amount': 230.0,
        }])
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 109.0,      'currency_id': foreign_curr.id,     'amount_currency': 218.0},
            # Receivable line:
            {'balance': -115.0,     'currency_id': foreign_curr.id,     'amount_currency': -230.0},
            # withholding line:
            {'balance': 1.0,        'currency_id': foreign_curr.id,     'amount_currency': 2.0},
            {'balance': 5.0,        'currency_id': foreign_curr.id,     'amount_currency': 10.0},
            # base lines:
            {'balance': 75.0,       'currency_id': foreign_curr.id,     'amount_currency': 150.0},
            {'balance': -75.0,      'currency_id': foreign_curr.id,     'amount_currency': -150.0},
            {'balance': 250.0,       'currency_id': foreign_curr.id,     'amount_currency': 500.0},
            {'balance': -250.0,      'currency_id': foreign_curr.id,     'amount_currency': -500.0},
        ])

    def test_withholding_tax_default_tax_on_product(self):
        """
        Simply test that an invoice having a product with a default withholding tax will cause
        that tax to appear on a default line in the wizard.
        """
        self.product_b.taxes_id = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [
                Command.create({
                    'product_id': self.product_b.id,
                }),
                Command.create({
                    'product_id': self.product_b.id,
                    'price_unit': 400.0,
                }),
            ],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'amount': 600.0,
            'withholding_net_amount': 594.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'base_amount': 600.0,
            'amount': 6.0,
        }])

    def test_withholding_not_payment_account_on_method_line(self):
        """ Test that when no payment account is set on the payment method line, the one from the wizard is used. """
        invoice_tax = self.percent_tax(15)
        withholding_tax = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)
        self.company_data['default_journal_bank'].inbound_payment_method_line_ids.payment_account_id = False

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(invoice_tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        with Form(payment_register) as payment_register_form:
            payment_register_form.should_withhold_tax = True
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax
                line.base_amount = 1000.0
            payment_register_form.withholding_outstanding_account_id = self.outstanding_account

        payment = payment_register._create_payments()
        outstanding = self.outstanding_account
        receivable = self.company_data['default_account_receivable']
        withholding_account = self.env.company.withholding_tax_base_account_id

        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 1140.0,     'account_id': outstanding.id},
            # Receivable line:
            {'balance': -1150.0,    'account_id': receivable.id},
            # withholding line:
            {'balance': 10.0,       'account_id': withholding_account.id},
            # base lines:
            {'balance': 1000.0,     'account_id': withholding_account.id},
            {'balance': -1000.0,    'account_id': withholding_account.id},
        ])

    def test_withholding_tax_grids(self):
        """ Test that tax grids are set as expected on the lines when they exist on the taxes. """
        base_tag_1 = self.env['account.account.tag'].create({
            'name': 'Base Tag 1',
            'applicability': 'taxes',
        })
        base_tag_2 = self.env['account.account.tag'].create({
            'name': 'Base Tag 2',
            'applicability': 'taxes',
        })
        tax_tag_1 = self.env['account.account.tag'].create({
            'name': 'Tax Tag 1',
            'applicability': 'taxes',
        })
        tax_tag_2 = self.env['account.account.tag'].create({
            'name': 'Tax Tag 2',
            'applicability': 'taxes',
        })

        invoice_tax = self.percent_tax(15)
        withholding_tax = self.percent_tax(
            amount=-1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
            invoice_repartition_line_ids=[
                Command.create({'repartition_type': 'base', 'factor_percent': 100.0, 'tag_ids': base_tag_1.ids}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 100.0, 'tag_ids': tax_tag_1.ids}),
            ],
            refund_repartition_line_ids=[
                Command.create({'repartition_type': 'base', 'factor_percent': 100.0, 'tag_ids': base_tag_1.ids}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 100.0, 'tag_ids': tax_tag_1.ids}),
            ],
        )
        withholding_tax_2 = self.percent_tax(
            amount=-2,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
            invoice_repartition_line_ids=[
                Command.create({'repartition_type': 'base', 'factor_percent': 100.0, 'tag_ids': base_tag_2.ids}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 100.0, 'tag_ids': tax_tag_2.ids}),
            ],
            refund_repartition_line_ids=[
                Command.create({'repartition_type': 'base', 'factor_percent': 100.0, 'tag_ids': base_tag_2.ids}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 100.0, 'tag_ids': tax_tag_2.ids}),
            ],
        )

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(invoice_tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        with Form(payment_register) as payment_register_form:
            payment_register_form.should_withhold_tax = True
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax
                line.base_amount = 1000.0
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax_2
                line.base_amount = 1000.0

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 1120.0,     'tax_tag_ids': []},
            # Receivable line:
            {'balance': -1150.0,    'tax_tag_ids': []},
            # withholding line:
            {'balance': 10.0,       'tax_tag_ids': tax_tag_1.ids},
            {'balance': 20.0,       'tax_tag_ids': tax_tag_2.ids},
            # base lines:
            {'balance': 1000.0,     'tax_tag_ids': []},
            {'balance': -1000.0,    'tax_tag_ids': base_tag_1.ids},
            {'balance': 1000.0,     'tax_tag_ids': []},
            {'balance': -1000.0,    'tax_tag_ids': base_tag_2.ids},
        ])

    # We need the date to be fixed for the EPD part; to the date of the invoice.
    @freeze_time('2024-01-01')
    def test_register_payment__with_installments(self):
        """ When registering a payment with payment terms, the withholding amount should follow the terms. """
        withholding_tax = self.percent_tax(
            amount=-3,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
        )
        self.product_a.taxes_id = withholding_tax

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_payment_term_id': self.env.ref('account.account_payment_term_advance_60days').id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'amount': 300.0,
            'withholding_net_amount': 291.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'base_amount': 300.0,
            'amount': 9.0,
        }])

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 291.0},
            # Receivable line:
            {'balance': -300.0},
            # withholding line:
            {'balance': 9.0},
            # base lines:
            {'balance': 300.0},
            {'balance': -300.0},
        ])

    def test_withholding_tax_repartition_line(self):
        """ Ensure that a withholding tax with multiple tax repartition line triggers multiple lines in the final entry
        with correct tax tag, amount and account.
        """
        withholding_tax = self.percent_tax(
            -1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
            invoice_repartition_line_ids=[
                Command.create({'repartition_type': 'base', 'factor_percent': 100.0}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 60.0}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 40.0}),
            ],
            refund_repartition_line_ids=[
                Command.create({'repartition_type': 'base', 'factor_percent': 100.0}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 60.0}),
                Command.create({'repartition_type': 'tax', 'factor_percent': 40.0}),
            ],
        )
        self.product_b.taxes_id = withholding_tax
        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_b.id,
            })],
        })
        invoice.action_post()

        # We then open the wizard, and expect a single withholding line (There is only one tax!)
        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'amount': 200.0,
            'withholding_net_amount': 198.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'original_base_amount': 200.0,
            'original_tax_amount': 2.0,
            'base_amount': 200.0,
            'amount': 2.0,
        }])

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 198.0},
            # Receivable line:
            {'balance': -200.0},
            # withholding lines:
            {'balance': 1.2},
            {'balance': 0.8},
            # base line:
            {'balance': 200.0},
            # Counterpart:
            {'balance': -200.0},
        ])

    def test_withholding_analytic_distribution(self):
        """ Ensure that the analytic distribution set on an invoice line is correctly applied to the final entry if the
        withholding tax is set to affect analytics.
        """
        withholding_tax = self.percent_tax(
            amount=-1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
            analytic=True,
        )
        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_b.id,
                'tax_ids': withholding_tax.ids,
                'analytic_distribution': {
                    self.analytic_account_3.id: 50,
                    self.analytic_account_4.id: 50,
                }
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'amount': 200.0,
            'withholding_net_amount': 198.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [{
            'original_base_amount': 200.0,
            'original_tax_amount': 2.0,
            'base_amount': 200.0,
            'amount': 2.0,
            'analytic_distribution': {
                str(self.analytic_account_3.id): 50,
                str(self.analytic_account_4.id): 50,
            },
        }])

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 198.0,    'analytic_distribution': False},
            # Receivable line:
            {'balance': -200.0,   'analytic_distribution': False},
            # withholding lines:
            {'balance': 2.0,      'analytic_distribution': {
                str(self.analytic_account_3.id): 50,
                str(self.analytic_account_4.id): 50,
            }},
            # base line:
            {'balance': 200.0,    'analytic_distribution': {
                str(self.analytic_account_3.id): 50,
                str(self.analytic_account_4.id): 50,
            }},
            # Counterpart:
            {'balance': -200.0,   'analytic_distribution': False},
        ])

    def test_withholding_analytic_distribution_two_invoice_line(self):
        """ Test that two invoice line with the same product/taxes but different analytic distribution will result in two
        withholding tax lines.
        """
        withholding_tax = self.percent_tax(
            amount=-1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
            analytic=True,
        )
        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_b.id,
                'tax_ids': withholding_tax.ids,
                'analytic_distribution': {
                    self.analytic_account_3.id: 50.0,
                    self.analytic_account_4.id: 50.0,
                }
            }),
            Command.create({
                'product_id': self.product_b.id,
                'tax_ids': withholding_tax.ids,
                'analytic_distribution': {
                    self.analytic_account_3.id: 25.0,
                    self.analytic_account_4.id: 75.0,
                }
            })
            ],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'amount': 400.0,
            'withholding_net_amount': 396.0,
        }])
        self.assertRecordValues(payment_register.withholding_line_ids, [
            {
                'base_amount': 200.0,
                'amount': 2.0,
                'analytic_distribution': {
                    str(self.analytic_account_3.id): 50.0,
                    str(self.analytic_account_4.id): 50.0,
                },
            },
            {
                'base_amount': 200.0,
                'amount': 2.0,
                'analytic_distribution': {
                    str(self.analytic_account_3.id): 25.0,
                    str(self.analytic_account_4.id): 75.0,
                },
            },
        ])

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'balance': 396.0,    'analytic_distribution': False},
            # Receivable line:
            {'balance': -400.0,   'analytic_distribution': False},
            # withholding lines:
            {'balance': 2.0,      'analytic_distribution': {
                str(self.analytic_account_3.id): 50.0,
                str(self.analytic_account_4.id): 50.0,
            }},
            {'balance': 2.0,      'analytic_distribution': {
                str(self.analytic_account_3.id): 25.0,
                str(self.analytic_account_4.id): 75.0,
            }},
            # base line:
            {'balance': 200.0,    'analytic_distribution': {
                str(self.analytic_account_3.id): 50.0,
                str(self.analytic_account_4.id): 50.0,
            }},
            {'balance': -200.0,   'analytic_distribution': False},
            {'balance': 200.0,    'analytic_distribution': {
                str(self.analytic_account_3.id): 25.0,
                str(self.analytic_account_4.id): 75.0,
            }},
            {'balance': -200.0,   'analytic_distribution': False},
        ])

    def test_outstanding_account_marked_as_reconcilable(self):
        """ Ensure that an account set as outstanding account in the wizard will be marked as reconcilable if it is not yet done. """
        tax = self.percent_tax(
            amount=-1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
        )
        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'currency_id': self.foreign_currency.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'tax_ids': [Command.set(tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({'withholding_outstanding_account_id': self.outstanding_account.id})
        payment_register._create_payments()
        self.assertRecordValues(self.outstanding_account, [{'reconcile': True}])

    @freeze_time('2024-01-01')
    def test_payment_synchronize_to_moves(self):
        """ Test that the payment and the journal entry behind it are synchronized as expected when the payment record is updated. """
        invoice_tax = self.percent_tax(15)
        withholding_tax = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(invoice_tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        with Form(payment_register) as payment_register_form:
            payment_register_form.should_withhold_tax = True
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax
                line.base_amount = 1000.0

        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'name': 'Manual Payment: INV/2024/00001',          'balance': 1140.0},
            # Receivable line:
            {'name': 'Manual Payment: INV/2024/00001',          'balance': -1150.0},
            # withholding line:
            {'name': 'WH Tax: 0001',                 'balance': 10.0},
            # base lines:
            {'name': 'WH Base: 0001',                'balance': 1000.0},
            {'name': 'WH Base Counterpart: 0001',    'balance': -1000.0},
        ])

        payment.action_draft()
        with Form(payment) as payment_form:
            with payment_form.withholding_line_ids.edit(0) as line:
                line.name = '0005'
                line.base_amount = 500.0
        self.assertRecordValues(payment.withholding_line_ids, [{
            'base_amount': 500.0,
            'amount': 5.0,
        }])
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {'name': 'Manual Payment: INV/2024/00001',      'balance': 1145.0},
            # Receivable line:
            {'name': 'Manual Payment: INV/2024/00001',      'balance': -1150.0},
            # withholding line:
            {'name': 'WH Tax: 0005',                        'balance': 5.0},
            # base lines:
            {'name': 'WH Base: 0005',                       'balance': 500.0},
            {'name': 'WH Base Counterpart: 0005',           'balance': -500.0},
        ])

    def test_display_withholding(self):
        """ Simple test that checks if display_withholding is set or not depending on the state of the database. """
        available_withholding_taxes = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)
        payment = self.env['account.payment'].create({
            'amount': 50.0,
            'payment_type': 'inbound',
            'partner_type': 'customer',
        })
        self.assertTrue(payment.display_withholding)
        available_withholding_taxes.unlink()
        payment = self.env['account.payment'].create({
            'amount': 50.0,
            'payment_type': 'inbound',
            'partner_type': 'customer',
        })
        self.assertFalse(payment.display_withholding)

    def test_withholding_line_base_amount(self):
        """ Test that a withholding line base amount cannot be less than or equal to 0 """
        self.product_a.taxes_id = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register'] \
            .with_context(active_model='account.move', active_ids=invoice.ids) \
            .create({})
        with self.assertRaises(UserError):
            with Form(payment_register) as payment_register_form:
                with payment_register_form.withholding_line_ids.edit(0) as line:
                    line.base_amount = -25.0

    def test_compute_outstanding_account_id(self):
        """ Test the correct behavior of the compute_outstanding_account_id method on the wizard.
        We should not have any default values the first time we register a payment with an outstanding account.
        The second time, the register payment wizard should find the previous outstanding account and use it as default.
        """
        self.company_data['default_journal_bank'].inbound_payment_method_line_ids.payment_account_id = False
        withholding_tax = self.percent_tax(
            amount=-1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
        )

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(withholding_tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({'withholding_outstanding_account_id': self.outstanding_account.id})
        payment_register._create_payments()

        invoice.mapped('line_ids').remove_move_reconcile()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        self.assertRecordValues(payment_register, [{
            'withholding_outstanding_account_id': self.outstanding_account.id,
        }])

    def test_cannot_register_negative_payment(self):
        """ Test that you cannot register a payment where the withholding amount is higher than the payment amount. """
        withholding_tax = self.percent_tax(-1, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(withholding_tax.ids)],
            })],
        })
        invoice.action_post()

        payment_register = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        with Form(payment_register) as payment_register_form:
            with payment_register_form.withholding_line_ids.new() as line:
                line.tax_id = withholding_tax
                line.base_amount = 999999.0
        with self.assertRaisesRegex(UserError, 'The withholding net amount cannot be negative.'):
            payment_register._create_payments()

    def test_placeholder_computation(self):
        """ Ensure that the placeholder computation is working as expected when changed in the form view.. """
        withholding_tax = self.percent_tax(
            -1,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
        )
        withholding_tax_2 = self.percent_tax(
            -2,
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
        )
        self.product_a.taxes_id = withholding_tax
        self.product_b.taxes_id = withholding_tax_2

        invoice = self.env["account.move"].create(
            {
                "move_type": "out_invoice",
                "partner_id": self.partner_a.id,
                "invoice_payment_term_id": self.env.ref("account.account_payment_term_advance_60days").id,
                "invoice_line_ids": [
                    Command.create({
                        "product_id": self.product_a.id,
                        "price_unit": 1000.0,
                    }),
                    Command.create({
                        "product_id": self.product_b.id,
                        "price_unit": 500.0,
                    }),
                ],
            }
        )
        invoice.action_post()

        AccountPaymentRegister = self.env["account.payment.register"].with_context(
            active_model="account.move", active_ids=invoice.ids
        )
        with Form(AccountPaymentRegister) as payment_register_form:
            # By default, the placeholders will have the correct values due to the sequence.
            lines = payment_register_form.withholding_line_ids._records
            self.assertEqual(lines[0]['placeholder_value'], '0001')
            self.assertEqual(lines[1]['placeholder_value'], '0002')

            with payment_register_form.withholding_line_ids.edit(0) as line_form:
                line_form.name = "0008"  # Manual override

            # We expect the placeholder to hold the correct value for line 0, and to restart counting at line 1
            lines = payment_register_form.withholding_line_ids._records
            self.assertEqual(lines[0]['placeholder_value'], False)
            self.assertEqual(lines[1]['placeholder_value'], '0001')

            with payment_register_form.withholding_line_ids.edit(0) as line_form:
                line_form.name = ""  # reset

            # We expect the placeholder to recompute as they were at the start
            lines = payment_register_form.withholding_line_ids._records
            self.assertEqual(lines[0]['placeholder_value'], '0001')
            self.assertEqual(lines[1]['placeholder_value'], '0002')

    def test_manual_adjustments(self):
        """ Ensure that when manually adjusting the base or tax amount of a line, the manually set amount is saved. """
        withholding_tax = self.percent_tax(-2, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(withholding_tax.ids)],
            })],
        })
        invoice.action_post()

        AccountPaymentRegister = self.env["account.payment.register"].with_context(
            active_model="account.move", active_ids=invoice.ids
        )
        with Form(AccountPaymentRegister) as payment_register_form:
            line = payment_register_form.withholding_line_ids._records[0]
            self.assertEqual(line['base_amount'], 1000)
            self.assertEqual(line['amount'], 20)
            with payment_register_form.withholding_line_ids.edit(0) as line_form:
                line_form.name = "0008"
                line_form.base_amount = 500
            self.assertEqual(line['base_amount'], 500)
            self.assertEqual(line['amount'], 10)
            with payment_register_form.withholding_line_ids.edit(0) as line_form:
                line_form.amount = 11
            self.assertEqual(line['base_amount'], 500)
            self.assertEqual(line['amount'], 11)

    def test_partner_is_set_on_lines(self):
        """ Test that the partner is set on the lines generated by the withholding tax on payment system. """
        withholding_tax = self.percent_tax(-10, is_withholding_tax_on_payment=True, withholding_sequence_id=self.withholding_sequence.id)

        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner_a.id,
            'invoice_line_ids': [Command.create({
                'product_id': self.product_a.id,
                'price_unit': 1000.0,
                'tax_ids': [Command.set(withholding_tax.ids)],
            })],
        })
        invoice.action_post()
        wizard = self.env['account.payment.register']\
            .with_context(active_model='account.move', active_ids=invoice.ids)\
            .create({})
        payment = wizard._create_payments()
        self.assertRecordValues(payment, [{
            'amount': 1000.0,
        }])
        self.assertRecordValues(payment.move_id.line_ids, [
            {'balance': 900.0,     'tax_ids': [],                    'partner_id': self.partner_a.id},
            {'balance': -1000.0,   'tax_ids': [],                    'partner_id': self.partner_a.id},
            {'balance': 100.0,     'tax_ids': [],                    'partner_id': self.partner_a.id},
            {'balance': 1000.0,    'tax_ids': [],                    'partner_id': self.partner_a.id},
            {'balance': -1000.0,   'tax_ids': withholding_tax.ids,   'partner_id': self.partner_a.id},
        ])

    def test_tax_repartition_on_refund(self):
        """ Test that the partner is set on the lines generated by the withholding tax on payment system. """
        base_tag = self.env["account.account.tag"].create({
            "name": "Base Tag",
            "applicability": "taxes",
        })
        tax_tag = self.env["account.account.tag"].create({
            "name": "Tax Tag",
            "applicability": "taxes",
        })
        withholding_tax = self.percent_tax(
            amount=-1,
            type_tax_use="purchase",
            is_withholding_tax_on_payment=True,
            withholding_sequence_id=self.withholding_sequence.id,
            invoice_repartition_line_ids=[
                Command.create({"repartition_type": "base", "factor_percent": 100.0, "tag_ids": base_tag.ids}),
                Command.create({"repartition_type": "tax", "factor_percent": 100.0, "tag_ids": tax_tag.ids}),
            ],
            refund_repartition_line_ids=[
                Command.create({"repartition_type": "base", "factor_percent": 100.0, "tag_ids": base_tag.ids}),
                Command.create({"repartition_type": "tax", "factor_percent": 100.0, "tag_ids": tax_tag.ids}),
            ],
        )
        invoice = self.env["account.move"].create({
            "move_type": "in_invoice",
            "partner_id": self.partner_a.id,
            "invoice_date": "2025-01-01",
            "invoice_line_ids": [
                Command.create(
                    {
                        "name": "WTH Line",
                        "price_unit": 1000.0,
                        "tax_ids": [Command.set(withholding_tax.ids)],
                    }
                )
            ],
        })
        invoice.action_post()

        payment_register = (
            self.env["account.payment.register"]
            .with_context(active_model="account.move", active_ids=invoice.ids)
            .create({})
        )
        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {"balance": -990.0,      "tax_tag_ids": []},
            # Receivable line:
            {"balance": 1000.0,      "tax_tag_ids": []},
            # withholding line:
            {"balance": -10.0,       "tax_tag_ids": tax_tag.ids},
            # base lines:
            {"balance": -1000.0,     "tax_tag_ids": []},
            {"balance": 1000.0,      "tax_tag_ids": base_tag.ids},
        ])

        move_reversal = (
            self.env["account.move.reversal"]
            .with_context(active_model="account.move", active_ids=invoice.ids)
            .create({"date": fields.Date.from_string("2025-02-01"), "journal_id": invoice.journal_id.id}))
        refund = self.env["account.move"].browse(move_reversal.refund_moves()["res_id"])
        payment_register = (
            self.env["account.payment.register"]
            .with_context(active_model="account.move", active_ids=refund.ids)
            .create({})
        )
        payment = payment_register._create_payments()
        self.assertRecordValues(payment.move_id.line_ids, [
            # Liquidity line:
            {"balance": 990.0,     "tax_tag_ids": []},
            # Receivable line:
            {"balance": -1000.0,    "tax_tag_ids": []},
            # withholding line:
            {"balance": 10.0,       "tax_tag_ids": tax_tag.ids},
            # base lines:
            {"balance": 1000.0,     "tax_tag_ids": []},
            {"balance": -1000.0,    "tax_tag_ids": base_tag.ids},
        ])
