# -*- coding: utf-8 -*-

import base64
from datetime import date, timedelta
from odoo import models, fields, api
from odoo.exceptions import UserError, ValidationError


class HrROE(models.Model):
    _name = 'hr.roe'
    _description = 'Record of Employment'
    _order = 'create_date desc'
    _inherit = ['mail.thread', 'mail.activity.mixin']

    # === ROE Reason Codes (Service Canada) ===
    ROE_REASON_CODES = [
        ('A', 'A - Shortage of work'),
        ('B', 'B - Strike or lockout'),
        ('D', 'D - Illness or injury'),
        ('E', 'E - Quit'),
        ('F', 'F - Maternity'),
        ('G', 'G - Retirement'),
        ('H', 'H - Work-Sharing'),
        ('J', 'J - Apprentice training'),
        ('K', 'K - Other'),
        ('M', 'M - Dismissal'),
        ('N', 'N - Leave of absence'),
        ('P', 'P - Parental'),
        ('Z', 'Z - Compassionate Care/Family Caregiver'),
    ]

    PAY_PERIOD_TYPES = [
        ('W', 'Weekly'),
        ('B', 'Bi-Weekly'),
        ('S', 'Semi-Monthly'),
        ('M', 'Monthly'),
    ]

    STATE_SELECTION = [
        ('draft', 'Draft'),
        ('ready', 'Ready to Submit'),
        ('submitted', 'Submitted'),
        ('archived', 'Archived'),
    ]

    name = fields.Char(
        string='Reference',
        required=True,
        copy=False,
        default=lambda self: self.env['ir.sequence'].next_by_code('hr.roe') or 'New',
    )
    state = fields.Selection(
        selection=STATE_SELECTION,
        string='Status',
        default='draft',
        tracking=True,
    )
    employee_id = fields.Many2one(
        'hr.employee',
        string='Employee',
        required=True,
        tracking=True,
    )
    company_id = fields.Many2one(
        'res.company',
        string='Company',
        required=True,
        default=lambda self: self.env.company,
    )

    # === Box 5: CRA Business Number ===
    cra_business_number = fields.Char(
        string='CRA Business Number (BN)',
        compute='_compute_cra_business_number',
        readonly=True,
        help='15-character format: 123456789RP0001',
    )

    @api.depends('company_id')
    def _compute_cra_business_number(self):
        """Get CRA business number from payroll settings."""
        for roe in self:
            if roe.company_id:
                settings = self.env['payroll.config.settings'].get_settings(roe.company_id.id)
                roe.cra_business_number = settings.get_cra_payroll_account_number() or roe.company_id.vat or ''
            else:
                roe.cra_business_number = ''

    # === Box 6: Pay Period Type ===
    pay_period_type = fields.Selection(
        selection=PAY_PERIOD_TYPES,
        string='Pay Period Type',
        compute='_compute_pay_period_type',
        store=True,
    )

    # === Box 8: Social Insurance Number ===
    sin_number = fields.Char(
        string='Social Insurance Number',
        related='employee_id.sin_number',
        readonly=True,
    )

    # === Box 10: First Day Worked ===
    first_day_worked = fields.Date(
        string='First Day Worked',
        related='employee_id.hire_date',
        readonly=True,
    )

    # === Box 11: Last Day for Which Paid ===
    last_day_paid = fields.Date(
        string='Last Day for Which Paid',
        required=True,
        tracking=True,
    )

    # === Box 12: Final Pay Period Ending Date ===
    final_pay_period_end = fields.Date(
        string='Final Pay Period Ending Date',
        required=True,
    )

    # === Box 13: Occupation ===
    occupation = fields.Char(
        string='Occupation',
        related='employee_id.job_title',
        readonly=True,
    )

    # === Box 14: Expected Date of Recall ===
    expected_recall_date = fields.Date(
        string='Expected Date of Recall',
        help='If temporary layoff, when employee is expected to return',
    )

    # === Box 15A: Total Insurable Hours ===
    total_insurable_hours = fields.Float(
        string='Total Insurable Hours',
        digits=(10, 2),
        help='Total hours worked during the insurable period',
    )

    # === Box 15B: Total Insurable Earnings ===
    total_insurable_earnings = fields.Float(
        string='Total Insurable Earnings',
        digits=(10, 2),
        help='Total earnings during the insurable period',
    )

    # === Box 15C: Insurable Earnings by Pay Period ===
    pay_period_earnings_ids = fields.One2many(
        'hr.roe.pay.period',
        'roe_id',
        string='Pay Period Earnings',
    )

    # === Box 16: Reason for Issuing ROE ===
    reason_code = fields.Selection(
        selection=ROE_REASON_CODES,
        string='Reason for Issuing ROE',
        required=True,
        tracking=True,
    )

    # === Box 17: Other Payments ===
    other_payments = fields.Text(
        string='Other Payments/Benefits',
        help='Other than regular pay, paid or payable at a later date',
    )

    # === Box 18: Comments ===
    comments = fields.Text(
        string='Comments',
    )

    # === Box 20: Communication Preference ===
    communication_language = fields.Selection([
        ('E', 'English'),
        ('F', 'French'),
    ], string='Communication Preference', default='E')

    # === Contact Information ===
    contact_name = fields.Char(
        string='Contact Person',
        default=lambda self: self.env.user.name,
    )
    contact_phone = fields.Char(
        string='Contact Phone',
    )

    # === File Attachments ===
    blk_file = fields.Binary(
        string='BLK File',
        attachment=True,
    )
    blk_filename = fields.Char(
        string='BLK Filename',
    )
    pdf_file = fields.Binary(
        string='PDF File',
        attachment=True,
    )
    pdf_filename = fields.Char(
        string='PDF Filename',
    )

    # === Submission Tracking ===
    submission_date = fields.Date(
        string='Submission Date',
        tracking=True,
    )
    submission_deadline = fields.Date(
        string='Submission Deadline',
        compute='_compute_submission_deadline',
        store=True,
    )
    service_canada_serial = fields.Char(
        string='Service Canada Serial Number',
        help='Serial number assigned after submission',
    )

    @api.depends('employee_id', 'employee_id.pay_schedule')
    def _compute_pay_period_type(self):
        mapping = {
            'weekly': 'W',
            'biweekly': 'B',
            'semi_monthly': 'S',
            'monthly': 'M',
        }
        for roe in self:
            schedule = roe.employee_id.pay_schedule if roe.employee_id else 'biweekly'
            roe.pay_period_type = mapping.get(schedule, 'B')

    @api.depends('last_day_paid')
    def _compute_submission_deadline(self):
        for roe in self:
            if roe.last_day_paid:
                # ROE must be submitted within 5 calendar days
                roe.submission_deadline = roe.last_day_paid + timedelta(days=5)
            else:
                roe.submission_deadline = False

    def action_calculate_earnings(self):
        """Calculate insurable earnings from payslips with proper period allocation"""
        self.ensure_one()
        
        if not self.employee_id:
            raise UserError('Please select an employee first.')
        
        # Find all payslips for this employee in the last year
        year_ago = self.last_day_paid - timedelta(days=365) if self.last_day_paid else date.today() - timedelta(days=365)
        
        payslips = self.env['hr.payslip'].search([
            ('employee_id', '=', self.employee_id.id),
            ('state', '=', 'done'),
            ('date_from', '>=', year_ago),
            ('date_to', '<=', self.last_day_paid or date.today()),
        ], order='date_from asc', limit=53)  # Max 53 pay periods, order ascending for period allocation
        
        if not payslips:
            raise UserError('No payslips found for this employee in the specified period.')
        
        Payslip = self.env['hr.payslip']
        
        # Track earnings by period
        # Key: period index (0-based), Value: total insurable earnings for that period
        period_earnings = {}
        total_hours = 0
        total_earnings = 0
        
        # Process each payslip
        for idx, payslip in enumerate(payslips):
            # Get worked hours for this payslip
            worked_days = payslip.worked_days_line_ids
            hours = sum(wd.number_of_hours for wd in worked_days) if worked_days else 0
            total_hours += hours
            
            # Break down earnings by pay type
            period_earnings_for_which = 0  # Earnings for this period (work period)
            period_earnings_in_which = 0   # Earnings for next period (pay date)
            
            for line in payslip.line_ids:
                code = line.code or ''
                category_code = line.category_id.code if line.category_id else None
                amount = abs(line.total or 0)
                
                # Use pay type helpers
                pay_type = Payslip._get_pay_type_from_code(code, category_code)
                is_reimbursement = Payslip._is_reimbursement(code, category_code)
                
                # Skip reimbursements - they are non-insurable
                if is_reimbursement:
                    continue
                
                # Skip union dues - they are deductions, not earnings
                if pay_type == 'union_dues':
                    continue
                
                # "For which period" allocation (work period)
                # Salary, Hourly, Overtime, Stat Holiday, Commission
                if pay_type in ['salary', 'hourly', 'overtime', 'stat_holiday', 'commission', 'other']:
                    period_earnings_for_which += amount
                
                # "In which period" allocation (pay date)
                # Bonus, Allowance, Vacation (paid as %)
                elif pay_type in ['bonus', 'allowance']:
                    period_earnings_in_which += amount
            
            # Allocate earnings to periods
            # "For which" earnings go to current period (idx)
            if idx not in period_earnings:
                period_earnings[idx] = 0
            period_earnings[idx] += period_earnings_for_which
            
            # "In which" earnings go to next period (idx + 1)
            # If it's the last payslip, allocate to current period
            next_period_idx = idx + 1 if idx < len(payslips) - 1 else idx
            if next_period_idx not in period_earnings:
                period_earnings[next_period_idx] = 0
            period_earnings[next_period_idx] += period_earnings_in_which
            
            # Add to total (both types are insurable)
            total_earnings += period_earnings_for_which + period_earnings_in_which
        
        # Clear existing pay period lines
        self.pay_period_earnings_ids.unlink()
        
        # Create pay period lines (ROE uses reverse order - most recent first)
        pay_period_data = []
        for period_idx in sorted(period_earnings.keys(), reverse=True):
            if period_idx < len(payslips):
                payslip = payslips[period_idx]
                earnings = period_earnings[period_idx]
                
                # ROE sequence numbers start from 1, most recent period is sequence 1
                sequence = len(payslips) - period_idx
                
                pay_period_data.append({
                    'roe_id': self.id,
                    'sequence': sequence,
                    'amount': earnings,
                    'payslip_id': payslip.id,
                })
        
        # Create new pay period lines
        if pay_period_data:
            self.env['hr.roe.pay.period'].create(pay_period_data)
        
        self.write({
            'total_insurable_hours': total_hours,
            'total_insurable_earnings': total_earnings,
        })
        
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': 'Earnings Calculated',
                'message': f'Found {len(payslips)} pay periods. Total: ${total_earnings:,.2f}',
                'type': 'success',
            }
        }

    def action_generate_blk(self):
        """Generate BLK file for ROE Web submission"""
        self.ensure_one()
        
        blk_content = self._generate_blk_xml()
        
        # Encode to base64
        blk_data = base64.b64encode(blk_content.encode('utf-8'))
        
        # Generate filename
        employee_name = self.employee_id.name.replace(' ', '_')
        today = date.today().strftime('%Y-%m-%d')
        filename = f'ROEForm_{employee_name}_{today}.blk'
        
        self.write({
            'blk_file': blk_data,
            'blk_filename': filename,
            'state': 'ready',
        })
        
        # Post the file to chatter as attachment
        attachment = self.env['ir.attachment'].create({
            'name': filename,
            'type': 'binary',
            'datas': blk_data,
            'res_model': self._name,
            'res_id': self.id,
            'mimetype': 'application/xml',
        })
        
        # Post message with attachment
        self.message_post(
            body=f'BLK file generated: <strong>{filename}</strong><br/>Ready for submission to Service Canada ROE Web.',
            attachment_ids=[attachment.id],
            message_type='notification',
        )
        
        # Return download action
        return {
            'type': 'ir.actions.act_url',
            'url': f'/web/content/{attachment.id}?download=true',
            'target': 'self',
        }

    def _generate_blk_xml(self):
        """Generate the XML content for BLK file in CRA-compliant format"""
        self.ensure_one()
        
        # Format SIN (remove dashes/spaces)
        sin = (self.sin_number or '').replace('-', '').replace(' ', '')
        
        # Employee address
        emp = self.employee_id
        
        # Build pay period earnings XML with proper indentation
        pp_lines = []
        for pp in self.pay_period_earnings_ids:
            pp_lines.append(f'''         <PP nbr="{pp.sequence}">
            <AMT>{pp.amount:.2f}</AMT>
         </PP>''')
        pp_xml = '\n'.join(pp_lines)
        
        # Contact phone parts
        phone = (self.contact_phone or '').replace('-', '').replace(' ', '').replace('(', '').replace(')', '')
        area_code = phone[:3] if len(phone) >= 10 else ''
        phone_number = phone[3:10] if len(phone) >= 10 else phone
        
        # Get first name and last name
        name_parts = (emp.name or '').split() if emp.name else ['', '']
        first_name = name_parts[0] if name_parts else ''
        last_name = ' '.join(name_parts[1:]) if len(name_parts) > 1 else ''
        
        # Contact name parts
        contact_parts = (self.contact_name or '').split() if self.contact_name else ['', '']
        contact_first = contact_parts[0] if contact_parts else ''
        contact_last = ' '.join(contact_parts[1:]) if len(contact_parts) > 1 else ''
        
        # Build XML with proper CRA formatting
        xml = f'''<?xml version="1.0" encoding="UTF-8"?>
<ROEHEADER FileVersion="W-2.0" ProductName="Fusion Payroll"
           SoftwareVendor="Nexa Systems Inc.">
    <ROE Issue="D" PrintingLanguage="{self.communication_language}">
      <B5>{self.cra_business_number or ''}</B5>
      <B6>{self.pay_period_type}</B6>
      <B8>{sin}</B8>
      <B9>
         <FN>{first_name}</FN>
         <LN>{last_name}</LN>
         <A1>{emp.home_street or ''}</A1>
         <A2>{emp.home_city or ''}</A2>
         <A3>{emp.home_province or 'ON'}, CA</A3>
         <PC>{(emp.home_postal_code or '').replace(' ', '')}</PC>
      </B9>
      <B10>{self.first_day_worked.strftime('%Y-%m-%d') if self.first_day_worked else ''}</B10>
      <B11>{self.last_day_paid.strftime('%Y-%m-%d') if self.last_day_paid else ''}</B11>
      <B12>{self.final_pay_period_end.strftime('%Y-%m-%d') if self.final_pay_period_end else ''}</B12>
      <B14>
         <CD>{'R' if self.expected_recall_date else 'U'}</CD>
      </B14>
      <B15A>{self.total_insurable_hours:.0f}</B15A>
      <B15C>
{pp_xml}
      </B15C>
      <B16>
         <CD>{self.reason_code}</CD>
         <FN>{contact_first}</FN>
         <LN>{contact_last}</LN>
         <AC>{area_code}</AC>
         <TEL>{phone_number}</TEL>
      </B16>
      <B20>{self.communication_language}</B20>
   </ROE>
</ROEHEADER>'''
        
        return xml

    def action_print_roe(self):
        """Print ROE as PDF"""
        self.ensure_one()
        return self.env.ref('fusion_payroll.action_report_roe').report_action(self)

    def action_mark_submitted(self):
        """Mark ROE as submitted to Service Canada"""
        self.ensure_one()
        self.write({
            'state': 'submitted',
            'submission_date': date.today(),
        })
        
        # Update employee ROE tracking
        self.employee_id.write({
            'roe_issued': True,
            'roe_issued_date': date.today(),
        })

    def action_archive(self):
        """Archive the ROE"""
        self.ensure_one()
        self.write({'state': 'archived'})


class HrROEPayPeriod(models.Model):
    _name = 'hr.roe.pay.period'
    _description = 'ROE Pay Period Earnings'
    _order = 'sequence'

    roe_id = fields.Many2one(
        'hr.roe',
        string='ROE',
        required=True,
        ondelete='cascade',
    )
    sequence = fields.Integer(
        string='Pay Period #',
        required=True,
    )
    amount = fields.Float(
        string='Insurable Earnings',
        digits=(10, 2),
    )
    payslip_id = fields.Many2one(
        'hr.payslip',
        string='Payslip',
    )