# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.

import base64
from datetime import timedelta

from odoo.addons.crm.tests.common import TestLeadConvertMassCommon
from odoo.fields import Datetime
from odoo.tests.common import tagged, users
from odoo.tools import mute_logger


class TestLeadMergeCommon(TestLeadConvertMassCommon):
    """ During a mixed merge (involving leads and opps), data should be handled a certain way following their type
    (m2o, m2m, text, ...). """

    @classmethod
    def setUpClass(cls):
        super(TestLeadMergeCommon, cls).setUpClass()

        cls.leads = cls.lead_1 + cls.lead_w_partner + cls.lead_w_contact + cls.lead_w_email + cls.lead_w_partner_company + cls.lead_w_email_lost
        # reset some assigned users to test salesmen assign
        (cls.lead_w_partner | cls.lead_w_email_lost).write({
            'user_id': False,
        })
        cls.lead_w_partner.write({'stage_id': False})

        cls.lead_w_contact.write({'description': 'lead_w_contact'})
        cls.lead_w_email.write({'description': 'lead_w_email'})
        cls.lead_1.write({'description': 'lead_1'})
        cls.lead_w_partner.write({'description': 'lead_w_partner'})

        cls.assign_users = cls.user_sales_manager + cls.user_sales_leads_convert + cls.user_sales_salesman


@tagged('lead_manage')
class TestLeadMerge(TestLeadMergeCommon):

    def _run_merge_wizard(self, leads):
        res = self.env['crm.merge.opportunity'].with_context({
            'active_model': 'crm.lead',
            'active_ids': leads.ids,
            'active_id': False,
        }).create({
            'team_id': False,
            'user_id': False,
        }).action_merge()
        return self.env['crm.lead'].browse(res['res_id'])

    def test_initial_data(self):
        """ Ensure initial data to avoid spaghetti test update afterwards

        Original order:

        lead_w_contact ----------lead---seq=3----proba=15
        lead_w_email ------------lead---seq=3----proba=15
        lead_1 ------------------lead---seq=1----proba=?
        lead_w_partner ----------lead---seq=False---proba=10
        lead_w_partner_company --lead---seq=False---proba=15
        """
        self.assertFalse(self.lead_1.date_conversion)
        self.assertEqual(self.lead_1.date_open, Datetime.from_string('2020-01-15 11:30:00'))
        self.assertEqual(self.lead_1.user_id, self.user_sales_leads)
        self.assertEqual(self.lead_1.team_id, self.sales_team_1)
        self.assertEqual(self.lead_1.stage_id, self.stage_team1_1)
        self.assertEqual(self.lead_1.probability, 20)
        self.assertTrue(self.lead_1.automated_probability > 0)
        self.assertFalse(self.lead_1.is_automated_probability)

        self.assertEqual(self.lead_w_partner.stage_id, self.env['crm.stage'])
        self.assertEqual(self.lead_w_partner.user_id, self.env['res.users'])
        self.assertEqual(self.lead_w_partner.team_id, self.sales_team_1)

        self.assertEqual(self.lead_w_partner_company.stage_id, self.stage_team1_1)
        self.assertEqual(self.lead_w_partner_company.user_id, self.user_sales_manager)
        self.assertEqual(self.lead_w_partner_company.team_id, self.sales_team_1)

        self.assertEqual(self.lead_w_contact.stage_id, self.stage_gen_1)
        self.assertEqual(self.lead_w_contact.user_id, self.user_sales_salesman)
        self.assertEqual(self.lead_w_contact.team_id, self.sales_team_convert)

        self.assertEqual(self.lead_w_email.stage_id, self.stage_gen_1)
        self.assertEqual(self.lead_w_email.user_id, self.user_sales_salesman)
        self.assertEqual(self.lead_w_email.team_id, self.sales_team_convert)

        self.assertEqual(self.lead_w_email_lost.stage_id, self.stage_team1_2)
        self.assertEqual(self.lead_w_email_lost.user_id, self.env['res.users'])
        self.assertEqual(self.lead_w_email_lost.team_id, self.sales_team_1)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_address_not_propagated(self):
        """All addresses have the same number of non-empty address fields, take the first one (lead_w_contact)
        because it's the lead that has the best confidence level after being sorted with '_sort_by_confidence_level'"""
        initial_address = {
            'street': 'Test street',
            'street2': 'Test street2',
            'city': 'Test City',
            'zip': '5000',
            'state_id': False,
            'country_id': self.env.ref('base.be'),
        }
        self.lead_w_contact.write(initial_address)

        (self.leads - self.lead_w_contact).write({
            'street': 'Other street',
            'street2': 'Other street2',
            'city': 'Other City',
            'zip': '6666',
            'state_id': self.env.ref('base.state_us_1'),
            'country_id': False,
        })

        leads = self.env['crm.lead'].browse(self.leads.ids)._sort_by_confidence_level(reverse=True)
        with self.assertLeadMerged(self.lead_w_contact, leads, **initial_address):
            leads._merge_opportunity(auto_unlink=False, max_length=None)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_address_propagated(self):
        """Test that the address with the most non-empty fields is propagated.

        Should take the address of "lead_w_partner" (maximum number of non-empty address
        fields and with an highest rank than "lead_w_email_lost")
        """
        self.leads.write({
            'street': 'Original street',
            'street2': False,
            'city': False,
            'zip': False,
            'state_id': False,
            'country_id': False,
        })
        new_address = {
            'street': 'New street',
            'street2': False,
            'city': 'New City',
            'zip': False,
            'state_id': False,
            'country_id': False,
        }
        self.lead_w_partner.write(new_address)
        self.lead_w_email_lost.write({
            'street': 'Other street',
            'street2': False,
            'city': 'Other City',
            'zip': False,
            'state_id': False,
            'country_id': False,
        })

        leads = self.env['crm.lead'].browse(self.leads.ids)._sort_by_confidence_level(reverse=True)

        with self.assertLeadMerged(self.lead_w_contact, leads, **new_address):
            leads._merge_opportunity(auto_unlink=False, max_length=None)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_internals(self):
        """ Test internals of merge wizard. In this test leads are ordered as

        lead_w_contact --lead---seq=3---probability=25
        lead_w_email ----lead---seq=3---probability=15
        lead_1 ----------lead---seq=1
        lead_w_partner --lead---seq=False
        """
        # ensure initial data
        self.lead_w_partner_company.action_set_won()  # won opps should be excluded

        merge = self.env['crm.merge.opportunity'].with_context({
            'active_model': 'crm.lead',
            'active_ids': self.leads.ids,
            'active_id': False,
        }).create({
            'user_id': self.user_sales_leads_convert.id,
        })
        self.assertEqual(merge.team_id, self.sales_team_convert)

        self.assertEqual(merge.opportunity_ids, self.leads - self.lead_w_partner_company, 'Should not keep won opps')
        ordered_merge = self.lead_w_contact + self.lead_w_email + self.lead_1 + self.lead_w_partner
        ordered_merge_description = '<br><br>'.join(l.description for l in ordered_merge)

        # merged opportunity: in this test, all input are leads. Confidence is based on stage
        # sequence -> lead_w_contact has a stage sequence of 3 and probability is greater
        result = merge.action_merge()
        merge_opportunity = self.env['crm.lead'].browse(result['res_id'])
        self.assertFalse((ordered_merge - merge_opportunity).exists())
        self.assertEqual(merge_opportunity, self.lead_w_contact)
        self.assertEqual(merge_opportunity.type, 'lead')
        self.assertEqual(merge_opportunity.description, ordered_merge_description)
        # merged opportunity has updated salesman / team / stage is ok as generic
        self.assertEqual(merge_opportunity.user_id, self.user_sales_leads_convert)
        self.assertEqual(merge_opportunity.team_id, self.sales_team_convert)
        self.assertEqual(merge_opportunity.stage_id, self.stage_gen_1)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_mixed(self):
        """ In case of mix, opportunities are on top, and result is an opportunity

        lead_1 -------------------opp----seq=1---probability=60
        lead_w_partner_company ---opp----seq=1---probability=50
        lead_w_contact -----------lead---seq=3---probability=25
        lead_w_email -------------lead---seq=3---probability=15
        lead_w_partner -----------lead---seq=False
        """
        # ensure initial data
        (self.lead_w_partner_company | self.lead_1).write({'type': 'opportunity'})
        self.lead_1.write({'probability': 60})

        self.assertEqual(self.lead_w_partner_company.stage_id.sequence, 1)
        self.assertEqual(self.lead_1.stage_id.sequence, 1)

        merge = self.env['crm.merge.opportunity'].with_context({
            'active_model': 'crm.lead',
            'active_ids': self.leads.ids,
            'active_id': False,
        }).create({
            'team_id': self.sales_team_convert.id,
            'user_id': False,
        })
        # TDE FIXME: see aa44700dccdc2618e0b8bc94252789264104047c -> no user, no team -> strange
        merge.write({'team_id': self.sales_team_convert.id})

        self.assertEqual(merge.opportunity_ids, self.leads, 'Even lost are included if asked by user')
        # remove lost lead, otherwise limit of 5 is going to raise
        merge.write({'opportunity_ids': [(3, self.lead_w_email_lost.id)]})
        self.assertEqual(merge.opportunity_ids, self.leads - self.lead_w_email_lost)
        ordered_merge = self.lead_w_partner_company + self.lead_w_contact + self.lead_w_email + self.lead_w_partner

        result = merge.action_merge()
        merge_opportunity = self.env['crm.lead'].browse(result['res_id'])
        self.assertFalse((ordered_merge - merge_opportunity).exists())
        self.assertEqual(merge_opportunity, self.lead_1)
        self.assertEqual(merge_opportunity.type, 'opportunity')

        # merged opportunity has same salesman (not updated in wizard)
        self.assertEqual(merge_opportunity.user_id, self.user_sales_leads)
        # TDE FIXME: as same uer_id is enforced, team is updated through onchange and therefore stage
        self.assertEqual(merge_opportunity.team_id, self.sales_team_convert)
        # self.assertEqual(merge_opportunity.team_id, self.sales_team_1)
        # TDE FIXME: BUT team_id is computed after checking stage, based on wizard's team_id
        self.assertEqual(merge_opportunity.stage_id, self.stage_team_convert_1)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_probability_auto(self):
        """ Check master lead keeps its automated probability when merged. """
        self.lead_1.write({'type': 'opportunity', 'probability': self.lead_1.automated_probability})
        self.assertTrue(self.lead_1.is_automated_probability)
        leads = self.env['crm.lead'].browse((self.lead_1 + self.lead_w_partner + self.lead_w_partner_company).ids)
        merged_lead = self._run_merge_wizard(leads)
        self.assertEqual(merged_lead, self.lead_1)
        self.assertTrue(merged_lead.is_automated_probability, "lead with Auto proba should remain with auto probability")

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_probability_auto_empty(self):
        """ Check master lead keeps its automated probability when merged
        even if its probability is 0. """
        self.lead_1.write({'type': 'opportunity', 'probability': 0, 'automated_probability': 0})
        self.assertTrue(self.lead_1.is_automated_probability)
        leads = self.env['crm.lead'].browse((self.lead_1 + self.lead_w_partner + self.lead_w_partner_company).ids)
        merged_lead = self._run_merge_wizard(leads)
        self.assertEqual(merged_lead, self.lead_1)
        self.assertTrue(merged_lead.is_automated_probability, "lead with Auto proba should remain with auto probability")

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_probability_manual(self):
        """ Check master lead keeps its manual probability when merged. """
        self.lead_1.write({'probability': 60})
        self.assertFalse(self.lead_1.is_automated_probability)
        leads = self.env['crm.lead'].browse((self.lead_1 + self.lead_w_partner + self.lead_w_partner_company).ids)
        merged_lead = self._run_merge_wizard(leads)
        self.assertEqual(merged_lead, self.lead_1)
        self.assertEqual(merged_lead.probability, 60, "Manual Probability should remain the same after the merge")
        self.assertFalse(merged_lead.is_automated_probability)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_lead_merge_probability_manual_empty(self):
        """ Check master lead keeps its manual probability when merged even if
        its probability is 0. """
        self.lead_1.write({'type': 'opportunity', 'probability': 0})
        leads = self.env['crm.lead'].browse((self.lead_1 + self.lead_w_partner + self.lead_w_partner_company).ids)
        merged_lead = self._run_merge_wizard(leads)
        self.assertEqual(merged_lead, self.lead_1)
        self.assertTrue(self.lead_1.automated_probability > 0)
        self.assertEqual(merged_lead.probability, 0, "Manual Probability should remain the same after the merge")
        self.assertFalse(merged_lead.is_automated_probability)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_merge_method(self):
        """ In case of mix, opportunities are on top, and result is an opportunity

        lead_1 -------------------opp----seq=1---probability=50
        lead_w_partner_company ---opp----seq=1---probability=50 (ID greater)
        lead_w_contact -----------lead---seq=3
        lead_w_email -------------lead---seq=3
        lead_w_partner -----------lead---seq=False
        """
        # ensure initial data
        (self.lead_w_partner_company | self.lead_1).write({'type': 'opportunity', 'probability': 50})
        leads = self.env['crm.lead'].browse(self.leads.ids)._sort_by_confidence_level(reverse=True)

        # lead_w_partner is lost, check that the "lost_reason" is not propagated
        # because "lead_1" is not lost
        lost_reason = self.env['crm.lost.reason'].create({'name': 'Test Reason'})
        self.lead_w_partner.write({
            'lost_reason_id': lost_reason,
            'probability': 0,
        })

        all_tags = self.leads.mapped('tag_ids')

        with self.assertLeadMerged(self.lead_1, leads,
                                   name='Nibbler Spacecraft Request',
                                   partner_id=self.contact_company_1,
                                   priority='2',
                                   lost_reason_id=False,
                                   tag_ids=all_tags):
            leads._merge_opportunity(auto_unlink=False, max_length=None)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_merge_method_propagate_lost_reason(self):
        """Check that the lost reason is propagated to the final lead if it's lost."""
        self.leads.write({
            'probability': 0,
            'automated_probability': 50,  # Do not automatically update the probability
        })

        lost_reason = self.env['crm.lost.reason'].create({'name': 'Test Reason'})
        self.lead_w_partner.lost_reason_id = lost_reason

        leads = self.env['crm.lead'].browse(self.leads.ids)._sort_by_confidence_level(reverse=True)

        with self.assertLeadMerged(leads[0], leads, lost_reason_id=lost_reason):
            leads._merge_opportunity(auto_unlink=False, max_length=None)

    @users('user_sales_manager')
    def test_lead_merge_properties_formatting(self):
        lead = self.lead_1
        partners = self.env['res.partner'].create([{'name': 'Alice'}, {'name': 'Bob'}])

        lead.lead_properties = [{
            'type': 'many2one',
            'comodel': 'res.partner',
            'name': 'test_many2one',
            'string': 'My Partner',
            'value': partners[0].id,
            'definition_changed': True,
        }, {
            'type': 'many2many',
            'comodel': 'res.partner',
            'name': 'test_many2many',
            'string': 'My Partners',
            'value': partners.ids,
        }, {
            'type': 'selection',
            'selection': [['a', 'A'], ['b', 'B']],
            'name': 'test_selection',
            'string': 'My Selection',
            'value': 'a',
        }, {
            'type': 'tags',
            'tags': [['a', 'A', 1], ['b', 'B', 2], ['c', 'C', 3]],
            'name': 'test_tags',
            'string': 'My Tags',
            'value': ['a', 'c'],
        }, {
            'type': 'boolean',
            'name': 'test_boolean',
            'string': 'My Boolean',
            'value': True,
        }, {
            'type': 'integer',
            'name': 'test_integer',
            'string': 'My Integer',
            'value': 1337,
        }, {
            'type': 'datetime',
            'name': 'test_datetime',
            'string': 'My Datetime',
            'value': '2022-02-21 16:11:42',
        }]

        expected = [{
            'label': 'My Partner',
            'value': 'Alice',
        }, {
            'label': 'My Partners',
            'values': [
                {'name': 'Alice'},
                {'name': 'Bob'},
            ],
        }, {
            'label': 'My Selection',
            'value': 'A',
        }, {
            'label': 'My Tags',
            'values': [
                {'name': 'A', 'color': 1},
                {'name': 'C', 'color': 3},
            ],
        }, {
            'label': 'My Boolean',
            'value': 'Yes',
        }, {
            'label': 'My Integer',
            'value': 1337,
        }, {
            'label': 'My Datetime',
            # datetime are stored as string because they are not JSONifiable
            'value': '2022-02-21 16:11:42',
        }]

        self.assertEqual(expected, lead._format_properties())

        # check the rendered template
        result = self.env['ir.qweb']._render(
            'crm.crm_lead_merge_summary',
            {'opportunities': lead, 'is_html_empty': lambda x: True})
        self.assertIn("o_tag_color_1", result)
        self.assertIn("Alice", result)
        self.assertIn("Bob", result)

    @users('user_sales_manager')
    def test_merge_method_dependencies(self):
        """ Test if dependences for leads are not lost while merging leads. In
        this test leads are ordered as

        lead_w_partner_company ---opp----seq=1 (ID greater)
        lead_w_contact -----------lead---seq=3
        lead_w_email -------------lead---seq=3----------------attachments
        lead_1 -------------------lead---seq=1----------------activity+meeting
        lead_w_partner -----------lead---seq=False
        """
        self.env['crm.lead'].browse(self.lead_w_partner_company.ids).write({'type': 'opportunity'})

        # create side documents
        attachments = self.env['ir.attachment'].create([
            {'name': '%02d.txt' % idx,
             'datas': base64.b64encode(b'Att%02d' % idx),
             'res_model': 'crm.lead',
             'res_id': self.lead_w_email.id,
            } for idx in range(4)
        ])
        lead_1 = self.env['crm.lead'].browse(self.lead_1.ids)
        activity = lead_1.activity_schedule('crm.lead_test_activity_1', user_id=self.user_sales_manager.id)
        calendar_event = self.env['calendar.event'].create({
            'name': 'Meeting with partner',
            'activity_ids': [(4, activity.id)],
            'start': '2021-06-12 21:00:00',
            'stop': '2021-06-13 00:00:00',
            'res_model_id': self.env['ir.model']._get('crm.crm_lead').id,
            'res_id': lead_1.id,
            'opportunity_id': lead_1.id,
        })

        # run merge and check documents are moved to the master record
        merge = self.env['crm.merge.opportunity'].with_context({
            'active_model': 'crm.lead',
            # with 'active_test' context key, lost are included, which would make 6 leads
            # while 5 is maximum for manual merge -> exclude it directly
            'active_ids': (self.leads - self.lead_w_email_lost).ids,
            'active_id': False,
        }).create({
            'team_id': self.sales_team_convert.id,
            'user_id': False,
        })
        result = merge.action_merge()
        master_lead = self.leads.filtered(lambda lead: lead.id == result['res_id'])

        # check result of merge process
        self.assertEqual(master_lead, self.lead_w_partner_company)
        # records updated
        self.assertEqual(calendar_event.opportunity_id, master_lead)
        self.assertEqual(calendar_event.res_id, master_lead.id)
        self.assertTrue(all(att.res_id == master_lead.id for att in attachments))
        # 2many accessors updated
        self.assertEqual(master_lead.activity_ids, activity)
        self.assertEqual(master_lead.calendar_event_ids, calendar_event)

    @users('user_sales_manager')
    @mute_logger('odoo.models.unlink')
    def test_merge_method_followers(self):
        """ Test that the followers of the leads are added in the destination lead.

        They should be added if:
        - The related partner was active on the lead (posted a message in the last 30 days)
        - The related partner is not already following the destination lead

        Leads                       Followers           Info
        ---------------------------------------------------------------------------------
        lead_w_contact              contact_1           OK (destination lead)
        lead_w_email                contact_1           KO (already following the destination lead)
                                    contact_2           OK (active on lead_w_email)
                                    contact_company     KO (most recent message on lead_w_email is 35 days ago, message
                                                            on lead_w_partner is not counted as they don't follow it)
        lead_w_partner              contact_2           KO (already added with lead_w_email)
        lead_w_partner_company
        """
        self.leads.message_follower_ids.unlink()
        self.leads.message_ids.unlink()

        self.lead_w_contact.message_subscribe([self.contact_1.id])
        self.lead_w_email.message_subscribe([self.contact_1.id, self.contact_2.id, self.contact_company.id])
        self.lead_w_partner.message_subscribe([self.contact_2.id])

        self.env['mail.message'].create([{
            'author_id': self.contact_1.id,
            'model': 'crm.lead',
            'res_id': self.lead_w_contact.id,
            'date': Datetime.now() - timedelta(days=1),
            'subtype_id': self.ref('mail.mt_comment'),
            'reply_to': False,
            'body': 'Test follower',
        }, {
            'author_id': self.contact_1.id,
            'model': 'crm.lead',
            'res_id': self.lead_w_email.id,
            'date': Datetime.now() - timedelta(days=20),
            'subtype_id': self.ref('mail.mt_comment'),
            'reply_to': False,
            'body': 'Test follower',
        }, {
            'author_id': self.contact_2.id,
            'model': 'crm.lead',
            'res_id': self.lead_w_email.id,
            'date': Datetime.now() - timedelta(days=15),
            'subtype_id': self.ref('mail.mt_comment'),
            'reply_to': False,
            'body': 'Test follower',
        }, {
            'author_id': self.contact_2.id,
            'model': 'crm.lead',
            'res_id': self.lead_w_partner.id,
            'date': Datetime.now() - timedelta(days=29),
            'subtype_id': self.ref('mail.mt_comment'),
            'reply_to': False,
            'body': 'Test follower',
        }, {
            'author_id': self.contact_company.id,
            'model': 'crm.lead',
            'res_id': self.lead_w_email.id,
            'date': Datetime.now() - timedelta(days=35),
            'subtype_id': self.ref('mail.mt_comment'),
            'reply_to': False,
            'body': 'Test follower',
        }, {
            'author_id': self.contact_company.id,
            'model': 'crm.lead',
            'res_id': self.lead_w_partner.id,
            'date': Datetime.now(),
            'subtype_id': self.ref('mail.mt_comment'),
            'reply_to': False,
            'body': 'Test follower',
        }])
        initial_followers = self.lead_w_contact.message_follower_ids

        leads = self.env['crm.lead'].browse(self.leads.ids)._sort_by_confidence_level(reverse=True)
        master_lead = leads._merge_opportunity(max_length=None)

        self.assertEqual(master_lead, self.lead_w_contact)

        # Check followers of the destination lead
        new_partner_followers = (master_lead.message_follower_ids - initial_followers).partner_id
        self.assertIn(self.contact_2, new_partner_followers,
                      'The partner must follow the destination lead')
        # "contact_company" posted a message 35 days ago on lead_2, so it's considered as inactive
        # "contact_company" posted a message now on lead_3, but they don't follow lead_3
        # so this message is just ignored
        self.assertNotIn(self.contact_company, new_partner_followers,
                         'The partner was not active on the lead')
        self.assertIn(self.contact_1, master_lead.message_follower_ids.partner_id,
                      'Should not have removed follower of the destination lead')
