# -*- coding: utf-8 -*-
# Copyright 2016 Therp BV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openerp.exceptions import ValidationError

from .test_partner_relation_common import TestPartnerRelationCommon


class TestPartnerRelation(TestPartnerRelationCommon):

    def setUp(self):
        super(TestPartnerRelation, self).setUp()

        # Create a new relation type which will not have valid relations:
        category_nobody = self.category_model.create({
            'name': 'Nobody',
        })
        (self.type_nobody,
         self.selection_nobody,
         self.selection_nobody_inverse) = (
            self._create_relation_type_selection({
                'name': 'has relation with nobody',
                'name_inverse': 'nobody has relation with',
                'contact_type_left': 'c',
                'contact_type_right': 'p',
                'partner_category_left': category_nobody.id,
                'partner_category_right': category_nobody.id,
            })
        )

    def _get_empty_relation(self):
        """Get empty relation record for onchange tests."""
        # Need English, because we will compare text
        return self.relation_all_model.with_context(lang='en_US').new({})

    def test_create_with_active_id(self):
        """Test creation with this_partner_id from active_id."""
        # Check wether we can create connection from company to person,
        # taking the particular company from the active records:
        relation = self.relation_all_model.with_context(
            active_id=self.partner_02_company.id,
            active_ids=self.partner_02_company.ids,
        ).create({
            'other_partner_id': self.partner_01_person.id,
            'type_selection_id': self.selection_company2person.id,
        })
        self.assertTrue(relation)
        self.assertEqual(relation.this_partner_id, self.partner_02_company)
        # Partner should have one relation now:
        self.assertEqual(self.partner_01_person.relation_count, 1)

    def test_display_name(self):
        """Test display name"""
        relation = self._create_company2person_relation()
        self.assertEqual(
            relation.display_name, '%s %s %s' % (
                relation.this_partner_id.name,
                relation.type_selection_id.name,
                relation.other_partner_id.name,
            )
        )

    def test__regular_write(self):
        """Test write with valid data."""
        relation = self._create_company2person_relation()
        relation.write({
            'date_start': '2014-09-01',
        })
        relation.invalidate_cache(ids=relation.ids)
        self.assertEqual(relation.date_start, '2014-09-01')

    def test_write_incompatible_dates(self):
        """Test write with date_end before date_start."""
        relation = self._create_company2person_relation()
        with self.assertRaises(ValidationError):
            relation.write({
                'date_start': '2016-09-01',
                'date_end': '2016-08-01',
            })

    def test_validate_overlapping_01(self):
        """Test create overlapping with no start / end dates."""
        relation = self._create_company2person_relation()
        with self.assertRaises(ValidationError):
            # New relation with no start / end should give error
            self.relation_all_model.create({
                'this_partner_id': relation.this_partner_id.id,
                'type_selection_id': relation.type_selection_id.id,
                'other_partner_id': relation.other_partner_id.id,
            })

    def test_validate_overlapping_02(self):
        """Test create overlapping with start / end dates."""
        relation = self.relation_all_model.create({
            'this_partner_id': self.partner_02_company.id,
            'type_selection_id': self.selection_company2person.id,
            'other_partner_id': self.partner_01_person.id,
            'date_start': '2015-09-01',
            'date_end': '2016-08-31',
        })
        # New relation with overlapping start / end should give error
        with self.assertRaises(ValidationError):
            self.relation_all_model.create({
                'this_partner_id': relation.this_partner_id.id,
                'type_selection_id': relation.type_selection_id.id,
                'other_partner_id': relation.other_partner_id.id,
                'date_start': '2016-08-01',
                'date_end': '2017-07-30',
            })

    def test_validate_overlapping_03(self):
        """Test create not overlapping."""
        relation = self.relation_all_model.create({
            'this_partner_id': self.partner_02_company.id,
            'type_selection_id': self.selection_company2person.id,
            'other_partner_id': self.partner_01_person.id,
            'date_start': '2015-09-01',
            'date_end': '2016-08-31',
        })
        relation_another_record = self.relation_all_model.create({
            'this_partner_id': relation.this_partner_id.id,
            'type_selection_id': relation.type_selection_id.id,
            'other_partner_id': relation.other_partner_id.id,
            'date_start': '2016-09-01',
            'date_end': '2017-08-31',
        })
        self.assertTrue(relation_another_record)

    def test_inverse_record(self):
        """Test creation of inverse record."""
        relation = self._create_company2person_relation()
        inverse_relation = self.relation_all_model.search([
            ('this_partner_id', '=', relation.other_partner_id.id),
            ('other_partner_id', '=', relation.this_partner_id.id),
        ])
        self.assertEqual(len(inverse_relation), 1)
        self.assertEqual(
            inverse_relation.type_selection_id.name,
            self.selection_person2company.name
        )

    def test_inverse_creation(self):
        """Test creation of record through inverse selection."""
        relation = self.relation_all_model.create({
            'this_partner_id': self.partner_01_person.id,
            'type_selection_id': self.selection_person2company.id,
            'other_partner_id': self.partner_02_company.id,
        })
        # Check wether display name is what we should expect:
        self.assertEqual(
            relation.display_name, '%s %s %s' % (
                self.partner_01_person.name,
                self.selection_person2company.name,
                self.partner_02_company.name,
            )
        )

    def test_unlink(self):
        """Unlinking derived relation should unlink base relation."""
        # Check wether underlying record is removed when record is removed:
        relation = self._create_company2person_relation()
        base_relation = relation.relation_id
        relation.unlink()
        self.assertFalse(base_relation.exists())

    def test_on_change_type_selection(self):
        """Test on_change_type_selection."""
        # 1. Test call with empty relation
        relation_empty = self._get_empty_relation()
        result = relation_empty.onchange_type_selection_id()
        self.assertTrue('domain' in result)
        self.assertFalse('warning' in result)
        self.assertTrue('this_partner_id' in result['domain'])
        self.assertFalse(result['domain']['this_partner_id'])
        self.assertTrue('other_partner_id' in result['domain'])
        self.assertFalse(result['domain']['other_partner_id'])
        # 2. Test call with company 2 person relation
        relation = self._create_company2person_relation()
        domain = relation.onchange_type_selection_id()['domain']
        self.assertTrue(
            ('is_company', '=', False) in domain['other_partner_id']
        )
        # 3. Test with relation needing categories.
        relation_ngo_volunteer = self.relation_all_model.create({
            'this_partner_id': self.partner_03_ngo.id,
            'type_selection_id': self.selection_ngo2volunteer.id,
            'other_partner_id': self.partner_04_volunteer.id,
        })
        domain = relation_ngo_volunteer.onchange_type_selection_id()['domain']
        self.assertTrue(
            ('category_id', 'in', [self.category_01_ngo.id]) in
            domain['this_partner_id']
        )
        self.assertTrue(
            ('category_id', 'in', [self.category_02_volunteer.id]) in
            domain['other_partner_id']
        )
        # 4. Test with invalid or impossible combinations
        relation_nobody = self._get_empty_relation()
        with self.env.do_in_draft():
            relation_nobody.type_selection_id = self.selection_nobody
        warning = relation_nobody.onchange_type_selection_id()['warning']
        self.assertTrue('message' in warning)
        self.assertTrue('No this partner available' in warning['message'])
        with self.env.do_in_draft():
            relation_nobody.this_partner_id = self.partner_02_company
        warning = relation_nobody.onchange_type_selection_id()['warning']
        self.assertTrue('message' in warning)
        self.assertTrue('incompatible' in warning['message'])
        # Allow left partner and check message for other partner:
        self.type_nobody.write({
            'partner_category_left': False,
        })
        self.selection_nobody.invalidate_cache(ids=self.selection_nobody.ids)
        warning = relation_nobody.onchange_type_selection_id()['warning']
        self.assertTrue('message' in warning)
        self.assertTrue('No other partner available' in warning['message'])

    def test_on_change_partner_id(self):
        """Test on_change_partner_id."""
        # 1. Test call with empty relation
        relation_empty = self._get_empty_relation()
        result = relation_empty.onchange_partner_id()
        self.assertTrue('domain' in result)
        self.assertFalse('warning' in result)
        self.assertTrue('type_selection_id' in result['domain'])
        self.assertFalse(result['domain']['type_selection_id'])
        # 2. Test call with company 2 person relation
        relation = self._create_company2person_relation()
        domain = relation.onchange_partner_id()['domain']
        self.assertTrue(
            ('contact_type_this', '=', 'c') in domain['type_selection_id']
        )
        # 3. Test with invalid or impossible combinations
        relation_nobody = self._get_empty_relation()
        with self.env.do_in_draft():
            relation_nobody.this_partner_id = self.partner_02_company
            relation_nobody.type_selection_id = self.selection_nobody
        warning = relation_nobody.onchange_partner_id()['warning']
        self.assertTrue('message' in warning)
        self.assertTrue('incompatible' in warning['message'])