from odoo import _, fields, models, tools


class IfcKpiDashboard(models.Model):
    _name = 'grt.ifc.kpi.dashboard'
    _description = 'IFC KPI Dashboard'
    _auto = False
    _order = 'name'

    name = fields.Char(string='Company', readonly=True)
    company_id = fields.Many2one('res.company', string='Company', readonly=True)

    total_count = fields.Integer(string='Total Documents', readonly=True)
    draft_count = fields.Integer(string='Draft', readonly=True)
    in_validation_count = fields.Integer(string='In Validation', readonly=True)
    waiting_production_count = fields.Integer(string='Waiting Produksi', readonly=True)
    waiting_provisioning_count = fields.Integer(string='Waiting Provisioning', readonly=True)
    approved_count = fields.Integer(string='Approved', readonly=True)
    rejected_count = fields.Integer(string='Rejected', readonly=True)
    approved_month_count = fields.Integer(string='Approved This Month', readonly=True)
    my_todo_count = fields.Integer(string='My To Do', compute='_compute_my_activity_cards')
    my_overdue_count = fields.Integer(string='My Overdue', compute='_compute_my_activity_cards')
    my_validation_count = fields.Integer(string='My Validation', compute='_compute_my_activity_cards')
    my_production_count = fields.Integer(string='My Pending Produksi', compute='_compute_my_activity_cards')
    my_provisioning_count = fields.Integer(string='My Pending Provisioning', compute='_compute_my_activity_cards')

    def _count_my_activities(self, company_id, approval_state=None, overdue=False):
        self.ensure_one()
        project_domain = [('company_id', '=', company_id)]
        if approval_state:
            project_domain.append(('approval_state', '=', approval_state))
        project_ids = self.env['grt.ifc.project'].search(project_domain).ids
        if not project_ids:
            return 0

        domain = [
            ('res_model', '=', 'grt.ifc.project'),
            ('res_id', 'in', project_ids),
            ('user_id', '=', self.env.user.id),
        ]
        if overdue:
            domain.append(('date_deadline', '<', fields.Date.today()))
        return self.env['mail.activity'].search_count(domain)

    def _get_my_activity_project_ids(self, company_id, approval_state=None, overdue=False):
        self.ensure_one()
        project_domain = [('company_id', '=', company_id)]
        if approval_state:
            project_domain.append(('approval_state', '=', approval_state))
        project_ids = self.env['grt.ifc.project'].search(project_domain).ids
        if not project_ids:
            return []

        domain = [
            ('res_model', '=', 'grt.ifc.project'),
            ('res_id', 'in', project_ids),
            ('user_id', '=', self.env.user.id),
        ]
        if overdue:
            domain.append(('date_deadline', '<', fields.Date.today()))
        activities = self.env['mail.activity'].search(domain)
        return list(set(activities.mapped('res_id')))

    def _compute_my_activity_cards(self):
        for record in self:
            company_id = record.company_id.id
            record.my_todo_count = record._count_my_activities(company_id)
            record.my_overdue_count = record._count_my_activities(company_id, overdue=True)
            record.my_validation_count = record._count_my_activities(company_id, approval_state='in_validation')
            record.my_production_count = record._count_my_activities(company_id, approval_state='waiting_production')
            record.my_provisioning_count = record._count_my_activities(company_id, approval_state='waiting_provisioning')

    def _open_documents(self, approval_state=None):
        self.ensure_one()
        domain = [('company_id', '=', self.company_id.id)]
        if approval_state:
            domain.append(('approval_state', '=', approval_state))

        return {
            'type': 'ir.actions.act_window',
            'name': _('Engineering IFC Documents'),
            'res_model': 'grt.ifc.project',
            'view_mode': 'list,form',
            'domain': domain,
            'context': {'search_default_filter_my_documents': 0},
            'target': 'current',
        }

    def action_open_all_documents(self):
        return self._open_documents()

    def action_open_waiting_production(self):
        return self._open_documents('waiting_production')

    def action_open_waiting_provisioning(self):
        return self._open_documents('waiting_provisioning')

    def action_open_validation(self):
        return self._open_documents('in_validation')

    def action_open_approved(self):
        return self._open_documents('approved')

    def action_open_rejected(self):
        return self._open_documents('rejected')

    def _open_my_activity_documents(self, approval_state=None, overdue=False):
        self.ensure_one()
        project_ids = self._get_my_activity_project_ids(
            self.company_id.id,
            approval_state=approval_state,
            overdue=overdue,
        )
        return {
            'type': 'ir.actions.act_window',
            'name': _('My Activity Documents'),
            'res_model': 'grt.ifc.project',
            'view_mode': 'list,form',
            'domain': [('id', 'in', project_ids)],
            'context': {'search_default_filter_my_documents': 0},
            'target': 'current',
        }

    def action_open_my_todo(self):
        return self._open_my_activity_documents()

    def action_open_my_overdue(self):
        return self._open_my_activity_documents(overdue=True)

    def action_open_my_validation(self):
        return self._open_my_activity_documents(approval_state='in_validation')

    def action_open_my_production(self):
        return self._open_my_activity_documents(approval_state='waiting_production')

    def action_open_my_provisioning(self):
        return self._open_my_activity_documents(approval_state='waiting_provisioning')

    def init(self):
        tools.drop_view_if_exists(self.env.cr, self._table)
        self.env.cr.execute(
            """
            CREATE OR REPLACE VIEW %(table)s AS (
                SELECT
                    c.id AS id,
                    c.id AS company_id,
                    c.name AS name,
                    COALESCE(COUNT(p.id), 0)::integer AS total_count,
                    COALESCE(SUM(CASE WHEN p.approval_state = 'draft' THEN 1 ELSE 0 END), 0)::integer AS draft_count,
                    COALESCE(SUM(CASE WHEN p.approval_state = 'in_validation' THEN 1 ELSE 0 END), 0)::integer AS in_validation_count,
                    COALESCE(SUM(CASE WHEN p.approval_state = 'waiting_production' THEN 1 ELSE 0 END), 0)::integer AS waiting_production_count,
                    COALESCE(SUM(CASE WHEN p.approval_state = 'waiting_provisioning' THEN 1 ELSE 0 END), 0)::integer AS waiting_provisioning_count,
                    COALESCE(SUM(CASE WHEN p.approval_state = 'approved' THEN 1 ELSE 0 END), 0)::integer AS approved_count,
                    COALESCE(SUM(CASE WHEN p.approval_state = 'rejected' THEN 1 ELSE 0 END), 0)::integer AS rejected_count,
                    COALESCE(
                        SUM(
                            CASE
                                WHEN p.approval_state = 'approved'
                                    AND p.approved_provisioning_at >= date_trunc('month', now())
                                    AND p.approved_provisioning_at < date_trunc('month', now()) + interval '1 month'
                                THEN 1
                                ELSE 0
                            END
                        ),
                        0
                    )::integer AS approved_month_count
                FROM res_company c
                LEFT JOIN grt_ifc_project p ON p.company_id = c.id
                GROUP BY c.id, c.name
            )
            """ % {'table': self._table}
        )