from odoo import models, fields, api, _
from dateutil.relativedelta import relativedelta
from datetime import datetime, timedelta


class GrantBenefit(models.Model):
    _inherit = 'grant.benefit'

    def action_second_accepted(self):
        super(GrantBenefit, self).action_second_accepted()
        for member in self.member_ids:
            if not member.is_new and member.member_status == 'benefit':
                member.is_restricted = True
                member.is_new = True
            sponsorships_main = self.env['donations.details.lines'].search([
                            ('benefit_id', '=', member.id,),('state', '=', 'active')
                        ])
            sponsorships_multi = self.env['donations.details.lines'].search([
                            ('benefit_ids', 'in', member.id),('state', '=', 'active')
                        ])
            sponsorships = sponsorships_main | sponsorships_multi
            if sponsorships:
                for sponsorship in sponsorships:
                    if member.member_status and member.member_status == 'non_benefit' and sponsorship.record_type == 'sponsorship':
                        sponsorship.sudo().write({'state': 'replace'})



class FamilyMember(models.Model):
    _inherit = 'family.member'

    donation_details_count = fields.Integer(
        string='Donation Details',
        compute='_compute_donation_details_count'
    )
    sponsor_id = fields.Many2one('res.partner', string='Sponsor Partner', domain="[('is_sponsor_portal', '=', True)]")
    sponsor_related_id = fields.Many2one('res.partner', string='Sponsor')
    sponsorship_id = fields.Many2one('takaful.sponsorship', string='Sponsorship')
    sponsorship_end_date = fields.Date(string='Sponsorship End Date')
    is_restricted = fields.Boolean(string="Is Restricted ?", default=False, readonly=True)
    is_new = fields.Boolean(string="Is new ?", default=False, readonly=True)
    general_restriction = fields.Boolean(string="General Restriction", default=False, readonly=True)
    kafala_status = fields.Selection(
        [('have_kafala', 'Have Kafala'), ('have_not_kafala', 'Have not Kafala')],
        string='Kafala Status',  compute='_compute_kafala_status', store=True, readonly=True)
    education_levels = fields.Many2one("education.level", string='Education Levels', compute='_compute_education_levels', store=True)
    number_of_family_member = fields.Integer(compute='_compute_number_of_family_member' , store=True, string='Number Of Family Member')
    benefit_group = fields.Selection(
        [
            ('orphan', 'Orphans'),
            ('widow', 'Widows'),
            ('other', 'Other'),
        ],
        compute='_compute_benefit_group',
        store=True
    )

    def name_get(self):
        result = []
        show_age = self.env.context.get('show_age_in_kafalat')

        for rec in self:
            name = rec.name or ''
            age = rec.age
            type = ''
            if show_age and age:
                if rec.benefit_group:
                    type = rec.benefit_group
                name = f"{name} -  {age} - {type}"
            result.append((rec.id, name))

        return result

    @api.depends('relationn_type')
    def _compute_benefit_group(self):
        for rec in self:
            if rec.relationn_type in ('son', 'daughter'):
                rec.benefit_group = 'orphan'
            elif rec.relationn_type in ('mother', 'replacement_mother'):
                rec.benefit_group = 'widow'
            else:
                rec.benefit_group = 'other'

    @api.depends('benefit_id','relationn','member_status')
    def _compute_number_of_family_member(self):
        for rec in self:
            if rec.relationn.relation_type in ('mother', 'replacement_mother'):
                family_members = rec.benefit_id.member_ids.filtered(
                    lambda m: m.relationn.relation_type in ('daughter', 'son') and m.member_status == 'benefit'
                )
                rec.number_of_family_member = len(family_members)


    @api.depends('member_education_status_ids', 'education_status', 'member_education_status_ids.case_study')
    def _compute_education_levels(self):
        for record in self:
            record.education_levels = False
            if record.education_status == 'educated':
                rec = record.member_education_status_ids.filtered(
                    lambda r: r.case_study == 'continuous'
                ).sorted(
                    lambda r: r.create_date, reverse=True
                )[:1]
                record.education_levels = rec.education_levels if rec else False

    @api.depends('sponsor_related_id')
    def _compute_kafala_status(self):
        for rec in self:
            rec.kafala_status = 'have_kafala' if rec.sponsor_related_id else 'have_not_kafala'

    def _compute_donation_details_count(self):
        for rec in self:
            rec.donation_details_count = self.env['donations.details.lines'].search_count([
                '|',
                ('benefit_id', '=', rec.id),
                ('benefit_ids', 'in', rec.ids)
            ])

    def action_open_donation_detail(self):
        self.ensure_one()
        
        return {
            'name': _('Donation Details Lines'),
            'type': 'ir.actions.act_window',
            'res_model': 'donations.details.lines',
            'view_mode': 'tree,form',
            'domain': ['|', ('benefit_id', '=', self.id), ('benefit_ids', 'in', self.ids)],
            'context': {'create': False, 'delete': False},
        }

    def action_not_available_for_sponsorship(self):
        for rec in self:
            rec.general_restriction = True

    def action_available_for_sponsorship(self):
        for rec in self:
            rec.general_restriction = False

    @api.model
    def _cron_family_member_restriction(self):
        benefit_ids = self.env["family.member"].sudo().search([("is_restricted", "=", True)])
        today = fields.Date.today()
        restriction_period = self.env['ir.config_parameter'].sudo().get_param('odex_takaful.restriction_period')
        for benefit in benefit_ids:
            create_date = benefit.benefit_id.approve_date
            benefit_date = create_date + timedelta(days=int(restriction_period) or 0)
            benefit_date_to = today - timedelta(days=int(restriction_period) or 0)

            if benefit_date >= today or benefit_date <= benefit_date_to:
                benefit.is_restricted = False