# Part of Odoo. See LICENSE file for full copyright and licensing details.

import logging
from datetime import timedelta

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

_logger = logging.getLogger(__name__)


class PoyntSettlementBatch(models.Model):
    _name = 'poynt.settlement.batch'
    _description = 'Poynt Settlement Batch'
    _order = 'settlement_date desc, id desc'
    _rec_name = 'name'

    name = fields.Char(
        string="Batch Reference",
        required=True,
        readonly=True,
        default='/',
        copy=False,
    )
    settlement_date = fields.Date(
        string="Settlement Date",
        required=True,
        help="The date Elavon deposits into the bank (T+1 business day from transactions).",
    )
    transaction_date = fields.Date(
        string="Transaction Date",
        required=True,
        help="The date card transactions were processed at the terminal.",
    )
    provider_id = fields.Many2one(
        'payment.provider',
        string="Payment Provider",
        required=True,
        domain="[('code', '=', 'poynt')]",
        ondelete='restrict',
    )
    bank_statement_line_id = fields.Many2one(
        'account.bank.statement.line',
        string="Bank Statement Line",
        help="The Elavon deposit line on the bank statement.",
        ondelete='set null',
    )
    line_ids = fields.One2many(
        'poynt.settlement.line',
        'batch_id',
        string="Settlement Lines",
    )
    state = fields.Selection([
        ('draft', "Draft"),
        ('matched', "Matched"),
        ('reconciled', "Reconciled"),
        ('error', "Error"),
    ], string="Status", required=True, default='draft', tracking=True)

    currency_id = fields.Many2one(
        'res.currency',
        string="Currency",
        required=True,
        default=lambda self: self.env.company.currency_id,
    )
    poynt_total = fields.Monetary(
        string="Poynt Total",
        currency_field='currency_id',
        compute='_compute_totals',
        store=True,
        help="Sum of all Poynt transactions (sales - refunds) for this batch.",
    )
    elavon_deposit = fields.Monetary(
        string="Elavon Deposit",
        currency_field='currency_id',
        help="The amount Elavon deposited into the bank account.",
    )
    fee_amount = fields.Monetary(
        string="Processing Fees",
        currency_field='currency_id',
        compute='_compute_totals',
        store=True,
        help="Difference between Poynt total and Elavon deposit (Elavon processing fees).",
    )
    sale_count = fields.Integer(
        string="Sales",
        compute='_compute_totals',
        store=True,
    )
    refund_count = fields.Integer(
        string="Refunds",
        compute='_compute_totals',
        store=True,
    )
    matched_count = fields.Integer(
        string="Matched to Customers",
        compute='_compute_totals',
        store=True,
    )
    notes = fields.Text(string="Notes")

    _sql_constraints = [
        ('unique_provider_txn_date', 'unique(provider_id, transaction_date)',
         'A settlement batch already exists for this provider and transaction date.'),
    ]

    @api.model_create_multi
    def create(self, vals_list):
        for vals in vals_list:
            if vals.get('name', '/') == '/':
                vals['name'] = self.env['ir.sequence'].next_by_code(
                    'poynt.settlement.batch'
                ) or '/'
        return super().create(vals_list)

    @api.depends('line_ids.amount', 'line_ids.action', 'line_ids.partner_id', 'elavon_deposit')
    def _compute_totals(self):
        for batch in self:
            sales = sum(
                line.amount for line in batch.line_ids if line.action == 'SALE'
            )
            refunds = sum(
                line.amount for line in batch.line_ids if line.action == 'REFUND'
            )
            net = sales - refunds
            batch.poynt_total = net
            batch.fee_amount = net - batch.elavon_deposit if batch.elavon_deposit else 0.0
            batch.sale_count = len(batch.line_ids.filtered(lambda l: l.action == 'SALE'))
            batch.refund_count = len(batch.line_ids.filtered(lambda l: l.action == 'REFUND'))
            batch.matched_count = len(batch.line_ids.filtered(lambda l: l.partner_id))

    # === BUSINESS METHODS === #

    def action_fetch_transactions(self):
        """Fetch Poynt transactions for this batch's transaction date."""
        self.ensure_one()
        if self.line_ids:
            raise UserError(_("This batch already has transaction lines. Clear them first."))

        provider = self.provider_id
        transactions = provider._poynt_fetch_settlement_transactions(
            self.transaction_date, self.transaction_date,
        )

        lines_vals = []
        existing_txn_ids = set()
        for txn in transactions:
            txn_id = txn.get('id', '')
            if txn_id in existing_txn_ids:
                continue
            existing_txn_ids.add(txn_id)

            action = txn.get('action', '')
            if action not in ('SALE', 'REFUND'):
                continue

            status = txn.get('processorResponse', {}).get('status', '')
            settlement = txn.get('settlementStatus', '')
            if status != 'Approved' and settlement != 'SETTLED':
                continue

            amounts = txn.get('amounts', {})
            amount_cents = amounts.get('transactionAmount', 0)
            amount = amount_cents / 100.0

            card = txn.get('fundingSource', {}).get('card', {})

            # Convert ISO 8601 timestamp (2025-03-05T19:19:10Z) to Odoo format
            created_at = txn.get('createdAt', '')
            if created_at:
                created_at = created_at.replace('T', ' ').replace('Z', '')

            lines_vals.append({
                'batch_id': self.id,
                'poynt_transaction_id': txn_id,
                'poynt_order_id': txn.get('context', {}).get('orderId', ''),
                'transaction_date': created_at,
                'amount': amount,
                'card_brand': card.get('type', ''),
                'card_last4': card.get('numberLast4', ''),
                'card_holder_name': card.get('cardHolderFullName', ''),
                'action': action,
                'state': 'fetched',
            })

        if lines_vals:
            self.env['poynt.settlement.line'].create(lines_vals)

        _logger.info(
            "Poynt settlement batch %s: fetched %d transactions for %s",
            self.name, len(lines_vals), self.transaction_date,
        )
        return True

    def action_match_deposit(self):
        """Match this batch to an Elavon bank statement line."""
        self.ensure_one()
        if not self.line_ids:
            raise UserError(_("No transaction lines to match. Fetch transactions first."))

        # Look for Elavon deposit on the settlement date (or ±1 day for timing)
        StmtLine = self.env['account.bank.statement.line']
        domain = [
            ('journal_id.name', 'ilike', 'Scotia'),
            ('date', '>=', self.settlement_date - timedelta(days=1)),
            ('date', '<=', self.settlement_date + timedelta(days=1)),
            ('amount', '>', 0),
            ('payment_ref', 'ilike', 'ELAVON'),
            ('is_reconciled', '=', False),
        ]
        candidates = StmtLine.search(domain, order='date asc')

        if not candidates:
            self.notes = f"No unreconciled Elavon deposit found near {self.settlement_date}"
            return False

        # Try to find the closest match by amount
        net_amount = self.poynt_total
        best_match = None
        best_diff = float('inf')

        for line in candidates:
            diff = abs(line.amount - net_amount)
            # Allow up to 5% tolerance for processing fees
            if diff < best_diff and diff <= net_amount * 0.05:
                best_diff = diff
                best_match = line

        if best_match:
            self.write({
                'bank_statement_line_id': best_match.id,
                'elavon_deposit': best_match.amount,
                'settlement_date': best_match.date,
                'state': 'matched',
            })
            _logger.info(
                "Poynt batch %s matched to bank line %s (deposit $%.2f, fees $%.2f)",
                self.name, best_match.id, best_match.amount, self.fee_amount,
            )
            return True
        else:
            self.notes = (
                f"No matching Elavon deposit found. "
                f"Poynt net: ${net_amount:.2f}, "
                f"closest candidate: ${candidates[0].amount:.2f}"
            )
            return False

    def action_match_customers(self):
        """Attempt to match settlement lines to Odoo customers and invoices."""
        self.ensure_one()
        matched = 0
        for line in self.line_ids.filtered(lambda l: not l.partner_id and l.action == 'SALE'):
            if line._match_to_customer():
                matched += 1

        _logger.info(
            "Poynt batch %s: matched %d/%d lines to customers",
            self.name, matched, len(self.line_ids),
        )
        return True

    def action_create_payments(self):
        """Create account.payment records for matched settlement lines."""
        self.ensure_one()
        if self.state == 'reconciled':
            raise UserError(_("This batch is already reconciled."))

        payable_lines = self.line_ids.filtered(
            lambda l: l.partner_id and l.action == 'SALE' and l.state in ('fetched', 'matched') and not l.payment_id
        )

        if not payable_lines:
            raise UserError(_("No matched lines available for payment creation."))

        for line in payable_lines:
            line._create_customer_payment()

        # Check if all lines are processed
        all_paid = all(
            l.state in ('paid', 'error') or l.action == 'REFUND'
            for l in self.line_ids
        )
        if all_paid:
            self.state = 'reconciled'

        return True

    def action_reset_to_draft(self):
        """Reset batch to draft state."""
        self.ensure_one()
        self.write({'state': 'draft'})
        return True

    # === CRON === #

    @api.model
    def _cron_daily_settlement_sync(self):
        """Daily cron: fetch yesterday's transactions, match to today's deposit."""
        provider = self.env['payment.provider'].search([
            ('code', '=', 'poynt'),
            ('state', '=', 'enabled'),
        ], limit=1)
        if not provider:
            _logger.info("Poynt settlement cron: no active Poynt provider found.")
            return

        yesterday = fields.Date.today() - timedelta(days=1)
        today = fields.Date.today()

        # Check if batch already exists
        existing = self.search([
            ('provider_id', '=', provider.id),
            ('transaction_date', '=', yesterday),
        ])
        if existing:
            _logger.info("Poynt settlement cron: batch for %s already exists.", yesterday)
            return

        # Handle weekend: if today is Monday, fetch Fri+Sat+Sun
        weekday = yesterday.weekday()  # 0=Monday, 6=Sunday
        if weekday == 6:  # Sunday → fetch Fri-Sun, deposit Monday
            txn_date_from = yesterday - timedelta(days=2)  # Friday
        elif weekday == 5:  # Saturday → skip, will be batched with Sunday
            _logger.info("Poynt settlement cron: Saturday — will batch with Sunday/Monday.")
            return
        else:
            txn_date_from = yesterday

        batch = self.create({
            'provider_id': provider.id,
            'transaction_date': txn_date_from,
            'settlement_date': today,
        })

        try:
            # Fetch all transactions for the date range
            transactions = provider._poynt_fetch_settlement_transactions(
                txn_date_from, yesterday,
            )

            lines_vals = []
            seen = set()
            for txn in transactions:
                txn_id = txn.get('id', '')
                if txn_id in seen:
                    continue
                seen.add(txn_id)

                action = txn.get('action', '')
                if action not in ('SALE', 'REFUND'):
                    continue

                status = txn.get('processorResponse', {}).get('status', '')
                settlement = txn.get('settlementStatus', '')
                if status != 'Approved' and settlement != 'SETTLED':
                    continue

                amounts = txn.get('amounts', {})
                amount = amounts.get('transactionAmount', 0) / 100.0
                card = txn.get('fundingSource', {}).get('card', {})

                # Convert ISO 8601 timestamp to Odoo format
                created_at = txn.get('createdAt', '')
                if created_at:
                    created_at = created_at.replace('T', ' ').replace('Z', '')

                lines_vals.append({
                    'batch_id': batch.id,
                    'poynt_transaction_id': txn_id,
                    'poynt_order_id': txn.get('context', {}).get('orderId', ''),
                    'transaction_date': created_at,
                    'amount': amount,
                    'card_brand': card.get('type', ''),
                    'card_last4': card.get('numberLast4', ''),
                    'card_holder_name': card.get('cardHolderFullName', ''),
                    'action': action,
                    'state': 'fetched',
                })

            if lines_vals:
                self.env['poynt.settlement.line'].create(lines_vals)

            # Try to match to bank deposit
            batch.action_match_deposit()

            # Try to match customers
            batch.action_match_customers()

            _logger.info(
                "Poynt settlement cron: created batch %s with %d lines for %s→%s",
                batch.name, len(lines_vals), txn_date_from, yesterday,
            )
        except Exception as e:
            batch.write({'state': 'error', 'notes': str(e)})
            _logger.error("Poynt settlement cron failed: %s", e)


class PoyntSettlementLine(models.Model):
    _name = 'poynt.settlement.line'
    _description = 'Poynt Settlement Line'
    _order = 'transaction_date desc, id desc'

    batch_id = fields.Many2one(
        'poynt.settlement.batch',
        string="Settlement Batch",
        required=True,
        ondelete='cascade',
        index=True,
    )
    poynt_transaction_id = fields.Char(
        string="Poynt Transaction ID",
        required=True,
        index=True,
    )
    poynt_order_id = fields.Char(string="Poynt Order ID")
    transaction_date = fields.Datetime(string="Transaction Date")
    amount = fields.Monetary(
        string="Amount",
        currency_field='currency_id',
        required=True,
    )
    currency_id = fields.Many2one(
        related='batch_id.currency_id',
        store=True,
    )
    card_brand = fields.Char(string="Card Brand")
    card_last4 = fields.Char(string="Card Last 4", size=4)
    card_holder_name = fields.Char(string="Cardholder Name")
    partner_id = fields.Many2one(
        'res.partner',
        string="Customer",
        ondelete='set null',
    )
    invoice_id = fields.Many2one(
        'account.move',
        string="Matched Invoice",
        domain="[('move_type', '=', 'out_invoice')]",
        ondelete='set null',
    )
    payment_id = fields.Many2one(
        'account.payment',
        string="Payment",
        readonly=True,
        ondelete='set null',
    )
    action = fields.Selection([
        ('SALE', "Sale"),
        ('REFUND', "Refund"),
        ('VOID', "Void"),
    ], string="Action", required=True)
    state = fields.Selection([
        ('fetched', "Fetched"),
        ('matched', "Matched"),
        ('paid', "Payment Created"),
        ('error', "Error"),
    ], string="Status", required=True, default='fetched')
    match_method = fields.Char(
        string="Match Method",
        help="How this line was matched to a customer (e.g., 'odoo_txn', 'card_token', 'invoice_amount', 'name').",
    )
    notes = fields.Text(string="Notes")

    _sql_constraints = [
        ('unique_poynt_txn', 'unique(poynt_transaction_id)',
         'This Poynt transaction has already been recorded.'),
    ]

    # === CUSTOMER MATCHING === #

    def _match_to_customer(self):
        """Attempt to match this settlement line to an Odoo customer/invoice.

        Matching strategy (in priority order):
        1. Check poynt_transaction_id in payment.transaction (direct Odoo payment)
        2. Match by card_last4 against payment.token records
        3. Match by amount against open invoices within ±2 days
        4. Match by card_holder_name fuzzy search against res.partner

        :return: True if matched, False otherwise.
        """
        self.ensure_one()
        if self.partner_id:
            return True

        # Strategy 1: Direct Odoo payment transaction
        PaymentTxn = self.env['payment.transaction']
        odoo_txn = PaymentTxn.search([
            ('poynt_transaction_id', '=', self.poynt_transaction_id),
        ], limit=1)
        if odoo_txn and odoo_txn.partner_id:
            self.write({
                'partner_id': odoo_txn.partner_id.id,
                'invoice_id': odoo_txn.invoice_ids[:1].id if odoo_txn.invoice_ids else False,
                'match_method': 'odoo_txn',
                'state': 'matched',
            })
            return True

        # Strategy 2: Card token match
        if self.card_last4:
            token = self.env['payment.token'].search([
                ('payment_details', 'ilike', self.card_last4),
                ('provider_id.code', '=', 'poynt'),
            ], limit=1)
            if token and token.partner_id:
                self.write({
                    'partner_id': token.partner_id.id,
                    'match_method': 'card_token',
                    'state': 'matched',
                })
                # Try to find matching invoice
                self._match_invoice()
                return True

        # Strategy 3: Amount match against open invoices
        if self.amount and self.transaction_date:
            date = self.transaction_date.date() if self.transaction_date else fields.Date.today()
            invoices = self.env['account.move'].search([
                ('move_type', '=', 'out_invoice'),
                ('state', '=', 'posted'),
                ('payment_state', 'in', ('not_paid', 'partial')),
                ('amount_residual', '=', self.amount),
                ('invoice_date', '>=', date - timedelta(days=7)),
                ('invoice_date', '<=', date + timedelta(days=2)),
            ], limit=1)
            if invoices:
                self.write({
                    'partner_id': invoices.partner_id.id,
                    'invoice_id': invoices.id,
                    'match_method': 'invoice_amount',
                    'state': 'matched',
                })
                return True

        # Strategy 4: Cardholder name fuzzy match
        if self.card_holder_name:
            name = self.card_holder_name.strip()
            if len(name) >= 3:
                partners = self.env['res.partner'].search([
                    '|',
                    ('name', 'ilike', name),
                    ('name', 'ilike', name.split()[-1] if ' ' in name else name),
                ], limit=5)
                if len(partners) == 1:
                    self.write({
                        'partner_id': partners.id,
                        'match_method': 'name',
                        'state': 'matched',
                    })
                    self._match_invoice()
                    return True

        return False

    def _match_invoice(self):
        """Try to find a matching open invoice for this line's partner and amount."""
        self.ensure_one()
        if self.invoice_id or not self.partner_id:
            return

        invoices = self.env['account.move'].search([
            ('partner_id', '=', self.partner_id.id),
            ('move_type', '=', 'out_invoice'),
            ('state', '=', 'posted'),
            ('payment_state', 'in', ('not_paid', 'partial')),
            ('amount_residual', '=', self.amount),
        ], limit=1, order='invoice_date desc')
        if invoices:
            self.invoice_id = invoices.id

    # === PAYMENT CREATION === #

    def _create_customer_payment(self):
        """Create an account.payment for this matched settlement line."""
        self.ensure_one()
        if not self.partner_id:
            self.write({'state': 'error', 'notes': 'No customer matched'})
            return False
        if self.payment_id:
            return True

        try:
            # Use the provider's journal (Poynt payment journal)
            journal = self.batch_id.provider_id.journal_id
            if not journal:
                # Fall back to first bank journal
                journal = self.env['account.journal'].search([
                    ('type', '=', 'bank'),
                    ('company_id', '=', self.env.company.id),
                ], limit=1)

            payment_vals = {
                'partner_id': self.partner_id.id,
                'amount': self.amount,
                'currency_id': self.currency_id.id,
                'journal_id': journal.id,
                'payment_type': 'inbound',
                'partner_type': 'customer',
                'payment_method_line_id': journal.inbound_payment_method_line_ids[:1].id,
                'memo': f"Poynt {self.card_brand or 'Card'} ****{self.card_last4 or '????'} - {self.batch_id.name}",
            }

            payment = self.env['account.payment'].create(payment_vals)
            payment.action_post()

            self.write({
                'payment_id': payment.id,
                'state': 'paid',
            })

            # Reconcile with invoice if matched
            if self.invoice_id and self.invoice_id.payment_state in ('not_paid', 'partial'):
                try:
                    (payment.move_id.line_ids + self.invoice_id.line_ids).filtered(
                        lambda l: l.account_id.account_type == 'asset_receivable' and not l.reconciled
                    ).reconcile()
                except Exception as e:
                    _logger.warning(
                        "Could not auto-reconcile payment %s with invoice %s: %s",
                        payment.name, self.invoice_id.name, e,
                    )

            return True

        except Exception as e:
            self.write({'state': 'error', 'notes': str(e)})
            _logger.error(
                "Failed to create payment for settlement line %s: %s",
                self.poynt_transaction_id, e,
            )
            return False