from odoo import api, fields, models
from datetime import datetime, time
from dateutil.relativedelta import relativedelta


class HrEmployee(models.Model):
    _inherit = 'hr.employee'

    emp_type_id = fields.Many2one('hr.contract.type')
    probation_state = fields.Selection([
        ('not_applicable', 'Not Applicable'),
        ('probation', 'On Probation'),
        ('confirmed', 'Confirmed'),
        ('extended', 'Extended'),
        ('terminated', 'Terminated'),
    ], default='not_applicable')

    probation_start_date = fields.Date()
    probation_end_date = fields.Date(
        compute='_compute_probation_end_date',
        store=True
    )

    @api.depends('probation_start_date', 'milestone_days')
    def _compute_probation_end_date(self):
        for rec in self:
            if rec.probation_start_date and rec.milestone_days:
                rec.probation_end_date = (
                        rec.probation_start_date +
                        relativedelta(days=rec.milestone_days)
                )
            else:
                rec.probation_end_date = False

    milestone_days = fields.Integer(
        string='Milestone Days',
        required=True
    )

    probation_review_ids = fields.One2many(
        'hr.employee.probation.review',
        'employee_id'
    )

    def write(self, vals):
        res = super().write(vals)

        for emp in self:

            if (
                    emp.emp_type_id
                    and emp.probation_start_date
                    and emp.milestone_days
                    and not emp.probation_review_ids
            ):
                self.env['hr.employee.probation.review'].create({
                    'employee_id': emp.id,
                    'review_date': (
                            emp.probation_start_date +
                            relativedelta(days=emp.milestone_days)
                    ),
                    'milestone_days': emp.milestone_days,
                })

        return res

    def cron_probation_completion(self):

        today = fields.Date.today()

        employees = self.search([
            ('probation_state', '=', 'probation'),
            ('probation_end_date', '<=', today)
        ])

        for emp in employees:

            last_review = self.env[
                'hr.employee.probation.review'
            ].search([
                ('employee_id', '=', emp.id)
            ], limit=1, order='review_date desc')

            if last_review.outcome == 'confirmed':
                emp.probation_state = 'confirmed'

            elif last_review.outcome == 'extended':
                emp.probation_state = 'probation'

                emp.probation_end_date = (
                        emp.probation_end_date
                        + relativedelta(months=1)
                )

            elif last_review.outcome == 'terminated':
                emp.probation_state = 'terminated'

            else:
                pass

class HrEmployeeProbationReview(models.Model):
    _name = 'hr.employee.probation.review'
    _description = 'Employee Probation Review'
    _rec_name = 'employee_id'

    employee_id = fields.Many2one(
        'hr.employee',
        required=True
    )

    review_date = fields.Date(required=True)

    milestone_days = fields.Integer(
        string='Milestone Days'
    )

    manager_feedback = fields.Text()

    outcome = fields.Selection([
        ('pending', 'Pending'),
        ('confirmed', 'Confirmed'),
        ('extended', 'Extended'),
        ('terminated', 'Terminated')
    ], default='pending')

    extension_days = fields.Integer()

    def write(self, vals):
        result = super().write(vals)

        for review in self:

            if vals.get('outcome') == 'confirmed':
                review.employee_id.probation_state = 'confirmed'

            elif vals.get('outcome') == 'terminated':
                review.employee_id.probation_state = 'terminated'

            elif (
                    vals.get('outcome') == 'extended'
                    and review.extension_days
            ):

                review.employee_id.probation_state = 'probation'

                next_review_date = (
                        review.review_date +
                        relativedelta(days=review.extension_days)
                )

                self.create({
                    'employee_id': review.employee_id.id,
                    'review_date': next_review_date,
                    'milestone_days': review.extension_days,
                })

                review.employee_id.probation_end_date = next_review_date

        return result