# -*- coding: utf-8 -*-
# Copyright 2024-2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)

"""Technician visit report wizard.

Opened from a completed (or in-progress) repair.order. Captures:
- labour hours
- parts/consumables used
- recommended upsell products
- optional client signature

On confirm:
- writes labour + parts as repair.order lines (Odoo native operations)
- updates x_fc_actual_cost on the repair
- triggers variance reconciliation (sets x_fc_requires_requote if over threshold)
- if not requote: confirms the repair (state='under_repair' -> 'done' via Odoo native flow)
- offers an action_collect_payment shortcut to fire Poynt on the resulting invoice
"""

import logging

from markupsafe import Markup

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

_logger = logging.getLogger(__name__)


class RepairVisitReportWizard(models.TransientModel):
    _name = 'fusion.repair.visit.report.wizard'
    _description = 'Repair Visit Report Wizard'

    repair_id = fields.Many2one(
        'repair.order',
        string='Repair Order',
        required=True,
        readonly=True,
    )
    technician_id = fields.Many2one(
        'res.users',
        string='Technician',
        default=lambda self: self.env.user,
        domain="[('x_fc_is_field_staff', '=', True)]",
    )

    # Labour
    labour_hours = fields.Float(
        string='Labour Hours',
        required=True,
        default=1.0,
    )

    # Parts used (simple line model below)
    parts_line_ids = fields.One2many(
        'fusion.repair.visit.report.wizard.line',
        'wizard_id',
        string='Parts Used',
    )

    # Outcome
    notes = fields.Html(string='Technician Notes')
    found_another_issue = fields.Boolean(
        string='Found Another Issue',
        help='Tick to spawn a follow-up repair after saving this visit.',
    )

    # Variance display
    estimated_cost = fields.Monetary(
        related='repair_id.x_fc_estimated_cost',
        currency_field='company_currency_id',
        readonly=True,
    )
    actual_cost = fields.Monetary(
        string='Actual Cost',
        compute='_compute_actual_cost',
        currency_field='company_currency_id',
    )
    variance_pct = fields.Float(
        string='Variance %',
        compute='_compute_actual_cost',
    )
    requires_requote = fields.Boolean(
        compute='_compute_actual_cost',
    )

    company_currency_id = fields.Many2one(
        'res.currency',
        related='repair_id.company_currency_id',
        readonly=True,
    )

    @api.depends('labour_hours', 'parts_line_ids.subtotal', 'repair_id.x_fc_estimated_cost')
    def _compute_actual_cost(self):
        ICP = self.env['ir.config_parameter'].sudo()
        try:
            threshold_pct = float(ICP.get_param('fusion_repairs.variance_threshold_pct', '20'))
        except (ValueError, TypeError):
            threshold_pct = 20.0
        try:
            threshold_amt = float(ICP.get_param('fusion_repairs.variance_threshold_amount', '100'))
        except (ValueError, TypeError):
            threshold_amt = 100.0

        for w in self:
            catalog = w.repair_id.x_fc_service_catalog_id
            labour_rate = 0.0
            if catalog and catalog.service_product_id:
                labour_rate = catalog.service_product_id.list_price
            parts_total = sum(w.parts_line_ids.mapped('subtotal'))
            w.actual_cost = (w.labour_hours * labour_rate) + parts_total
            est = w.estimated_cost or 0.0
            variance_pct = ((w.actual_cost - est) / est * 100) if est else 0.0
            w.variance_pct = variance_pct
            # One-sided: only OVER-cost triggers re-quote. Coming in under
            # estimate is good news and must not block invoicing.
            over_pct = variance_pct
            over_amt = w.actual_cost - est
            w.requires_requote = est > 0 and (
                over_pct >= threshold_pct or over_amt >= threshold_amt
            )

    # ------------------------------------------------------------------
    # ACTION
    # ------------------------------------------------------------------
    def action_confirm(self):
        self.ensure_one()
        repair = self.repair_id
        if not repair:
            raise UserError(_('No repair selected.'))

        # Create native repair operations (stock moves) for the parts used.
        # 'add' type moves consume parts from the parts source location and
        # flow through to the invoice when action_create_sale_order() is run.
        self._create_repair_part_moves(repair)

        # Persist actual cost + requote flag on the repair.
        repair.write({
            'x_fc_actual_cost': self.actual_cost,
            'x_fc_requires_requote': self.requires_requote,
        })

        # Append technician notes to chatter.
        if self.notes:
            repair.message_post(body=self.notes)

        # Spawn a follow-up repair if the tech found another issue.
        stub = False
        if self.found_another_issue:
            stub = repair.copy({
                'state': 'draft',
                'internal_notes': _(
                    '<p><em>Spawned from visit report on %(ref)s. Add details for the new issue.</em></p>',
                    ref=repair.name,
                ),
                'x_fc_intake_source': 'manual',
                'x_fc_intake_session_id': repair.x_fc_intake_session_id,
                'x_fc_estimated_cost': 0.0,
                'x_fc_actual_cost': 0.0,
                'x_fc_requires_requote': False,
                'x_fc_intake_template_id': False,
                'x_fc_service_catalog_id': False,
                'x_fc_maintenance_contract_id': False,
            })
            repair.message_post(
                body=Markup(_(
                    'Spawned follow-up repair <b>%(name)s</b> for "found another issue".'
                )) % {'name': stub.name or ''},
            )

        # If a stub was spawned, open it directly so the tech can fill in details.
        target_id = stub.id if stub else repair.id
        target_name = stub.name if stub else repair.name
        return {
            'type': 'ir.actions.act_window',
            'name': target_name,
            'res_model': 'repair.order',
            'view_mode': 'form',
            'res_id': target_id,
        }

    def _create_repair_part_moves(self, repair):
        """Create stock.move records for each part used (repair_line_type='add').

        Locations follow the repair order's configured source / parts locations;
        Odoo natively links these moves to the SO line generated by
        action_create_sale_order() so they invoice correctly.
        """
        Move = self.env['stock.move'].sudo()
        for line in self.parts_line_ids:
            if not line.product_id or line.quantity <= 0:
                continue
            vals = {
                'name': line.product_id.display_name,
                'product_id': line.product_id.id,
                'product_uom_qty': line.quantity,
                'product_uom': line.product_id.uom_id.id,
                'repair_id': repair.id,
                'repair_line_type': 'add',
                'location_id': repair.location_id.id,
                'location_dest_id': repair.parts_location_id.id or repair.location_id.id,
                'company_id': repair.company_id.id,
            }
            try:
                Move.create(vals)
            except Exception as e:
                _logger.warning(
                    'Could not create repair part move on %s for %s: %s',
                    repair.name, line.product_id.display_name, e,
                )


class RepairVisitReportWizardLine(models.TransientModel):
    _name = 'fusion.repair.visit.report.wizard.line'
    _description = 'Repair Visit Report Wizard - Part Line'

    wizard_id = fields.Many2one(
        'fusion.repair.visit.report.wizard',
        required=True,
        ondelete='cascade',
    )
    product_id = fields.Many2one(
        'product.product',
        string='Part',
        required=True,
    )
    quantity = fields.Float(default=1.0, required=True)
    unit_price = fields.Float(string='Unit Price')
    subtotal = fields.Float(compute='_compute_subtotal', store=True)

    @api.onchange('product_id')
    def _onchange_product_id(self):
        if self.product_id:
            self.unit_price = self.product_id.list_price

    @api.depends('quantity', 'unit_price')
    def _compute_subtotal(self):
        for line in self:
            line.subtotal = line.quantity * line.unit_price