from decimal import Decimal
from importlib import import_module
from types import SimpleNamespace
from unittest import mock

from django.apps import apps
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import SimpleTestCase, TestCase, override_settings
from django.urls import reverse

from .calculator import Calculation, RouteOption, tariff_for
from .distances import DistanceError, _waypoint, fetch_route_matrix, search_settlements
from .forms import CostCalculatorForm
from farmerapp.models import CultureableName, District, Region
from .models import TariffImport, TransportTariff, UnloadingPoint, UnloadingPointImport, UnloadingPointPrice
from .point_import import apply_plan, export_rows, parse_points
from .sheets import SheetImportError, google_export_url, read_csv
from .tariff_import import find_gaps, parse_rows
from .templatetags.pricing_extras import duration, money


def tariff(km_from, km_to, rate):
    return SimpleNamespace(km_from=km_from, km_to=km_to, price_per_ton_km=Decimal(rate))


TARIFFS = [tariff(0, 25, '32'), tariff(26, 50, '18'), tariff(951, 1000, '2.6')]


class TariffForTests(SimpleTestCase):
    def test_distance_inside_range(self):
        self.assertEqual(tariff_for(Decimal('40'), TARIFFS), (TARIFFS[1], False))

    def test_fractional_distance_between_ranges_rounds_up(self):
        # 25.4 км не потрапляє ні в 0–25, ні в 26–50 без округлення вгору
        self.assertEqual(tariff_for(Decimal('25.4'), TARIFFS), (TARIFFS[1], False))

    def test_longer_than_table_uses_last_tariff(self):
        self.assertEqual(tariff_for(Decimal('1200'), TARIFFS), (TARIFFS[-1], True))

    def test_gap_in_table_has_no_tariff(self):
        self.assertEqual(tariff_for(Decimal('300'), TARIFFS), (None, False))


class FormattingTests(SimpleTestCase):
    def test_money(self):
        self.assertEqual(money(Decimal('1234567.8')), '1 234 568')
        self.assertEqual(money(Decimal('-2500')), '−2 500')
        self.assertEqual(money(Decimal('16.5'), 1), '16,5')
        self.assertEqual(money(None), '')

    def test_duration(self):
        self.assertEqual(duration(274), '4 год 34 хв')
        self.assertEqual(duration(45), '45 хв')
        self.assertEqual(duration(120), '2 год')


class RouteMatrixTests(SimpleTestCase):
    def test_coordinates_become_lat_lng_waypoint(self):
        self.assertEqual(_waypoint('46.48,30.72'),
                         {'waypoint': {'location': {'latLng': {'latitude': 46.48, 'longitude': 30.72}}}})
        self.assertEqual(_waypoint('Рені, Одеська область'), {'waypoint': {'address': 'Рені, Одеська область'}})

    def test_place_id_becomes_place_waypoint(self):
        self.assertEqual(_waypoint('place_id:ChIJabc'), {'waypoint': {'placeId': 'ChIJabc'}})

    @override_settings(GOOGLE_MAPS_API_KEY='')
    def test_missing_key(self):
        with self.assertRaises(DistanceError):
            fetch_route_matrix('Київ', ['Одеса'])

    @override_settings(GOOGLE_MAPS_API_KEY='key')
    def test_parses_response_in_destination_order(self):
        response = mock.Mock(status_code=200)
        response.json.return_value = [
            {'originIndex': 0, 'destinationIndex': 1, 'distanceMeters': 70000, 'duration': '4200s', 'condition': 'ROUTE_EXISTS'},
            {'originIndex': 0, 'destinationIndex': 0, 'condition': 'ROUTE_NOT_FOUND'},
        ]
        with mock.patch('pricing.distances.requests.post', return_value=response) as post:
            self.assertEqual(fetch_route_matrix('Київ', ['Нікуди', 'Рені']), [None, (70000, 4200)])
        self.assertEqual(post.call_args.kwargs['headers']['X-Goog-Api-Key'], 'key')

    @override_settings(GOOGLE_MAPS_API_KEY='key')
    def test_ip_restriction_is_explained(self):
        response = mock.Mock(status_code=403, text='')
        response.json.return_value = [{'error': {'code': 403, 'details': [
            {'reason': 'API_KEY_IP_ADDRESS_BLOCKED', 'metadata': {'callerIp': '2a01:4f9::1'}}]}}]
        with mock.patch('pricing.distances.requests.post', return_value=response):
            with self.assertRaisesMessage(DistanceError, 'IP-адреси сервера 2a01:4f9::1'):
                fetch_route_matrix('Київ', ['Одеса'])

    @override_settings(GOOGLE_MAPS_API_KEY='key')
    def test_http_error(self):
        response = mock.Mock(status_code=403, text='denied')
        response.json.side_effect = ValueError
        with mock.patch('pricing.distances.requests.post', return_value=response):
            with self.assertRaises(DistanceError):
                fetch_route_matrix('Київ', ['Одеса'])


class SettlementSearchTests(SimpleTestCase):
    @override_settings(GOOGLE_MAPS_API_KEY='key')
    def test_parses_suggestions(self):
        response = mock.Mock(status_code=200)
        response.json.return_value = {'suggestions': [
            {'placePrediction': {'placeId': 'p1', 'text': {'text': 'Рені, Одеська область, Україна'}}},
            {'queryPrediction': {'text': {'text': 'рені порт'}}},
        ]}
        with mock.patch('pricing.distances.requests.post', return_value=response):
            self.assertEqual(search_settlements('Рені'), [('p1', 'Рені, Одеська область, Україна')])

    @override_settings(GOOGLE_MAPS_API_KEY='key')
    def test_http_error(self):
        response = mock.Mock(status_code=403, text='denied')
        response.json.side_effect = ValueError
        with mock.patch('pricing.distances.requests.post', return_value=response):
            with self.assertRaises(DistanceError):
                search_settlements('Рені')


class CalculatorOriginTests(SimpleTestCase):
    def form_with(self, **cleaned):
        form = CostCalculatorForm()
        form.cleaned_data = {'farmer': None, 'settlement': None, **cleaned}
        return form

    def test_settlement_from_autocomplete(self):
        form = self.form_with(settlement='p1|Рені, Одеська область, Україна')
        self.assertEqual(form.clean_settlement(), {'place_id': 'p1', 'name': 'Рені, Одеська область, Україна'})

    def test_settlement_typed_by_hand(self):
        form = self.form_with(settlement='|с. Горохолин Ліс')
        self.assertEqual(form.clean_settlement(), {'place_id': '', 'name': 'с. Горохолин Ліс'})

    def test_settlement_is_preferred_over_farmer_address(self):
        farmer = SimpleNamespace(name='Агро', address='Київ', district=None, region=None)
        form = self.form_with(farmer=farmer, settlement={'place_id': 'p1', 'name': 'Рені'})
        self.assertEqual(form.origin, ('place_id:p1', 'населеного пункту Рені'))
        form = self.form_with(farmer=farmer, settlement={'place_id': '', 'name': 'Рені'})
        self.assertEqual(form.origin[0], 'Рені, Україна')

    def test_farmer_address_without_settlement(self):
        farmer = SimpleNamespace(name='Агро', address='Київ', district=None, region=None)
        self.assertEqual(self.form_with(farmer=farmer).origin, ('Київ', 'адреси господарства «Агро»'))


class TariffImportParsingTests(SimpleTestCase):
    def test_skips_header_and_sorts(self):
        rows = [['Кілометраж від', 'До', 'Ціна'], [26, 50, '18,5'], ['0', '25', 32], [None, None, None]]
        self.assertEqual(parse_rows(rows), [(0, 25, Decimal('32')), (26, 50, Decimal('18.5'))])

    def test_overlapping_ranges_rejected(self):
        with self.assertRaises(SheetImportError) as ctx:
            parse_rows([[0, 30, 10], [25, 50, 9]])
        self.assertIn('перетинаються', ctx.exception.errors[0])

    def test_broken_row_rejected(self):
        with self.assertRaises(SheetImportError):
            parse_rows([[0, 25, 32], [26, 'п\'ятдесят', 18]])

    def test_empty_table_rejected(self):
        with self.assertRaises(SheetImportError):
            parse_rows([['від', 'до', 'ціна']])

    def test_gaps(self):
        self.assertEqual(find_gaps([(0, 25, 1), (30, 50, 1), (51, 60, 1)]), [(26, 29)])

    def test_csv_with_semicolons(self):
        self.assertEqual(read_csv('від;до;ціна\n0;25;6,4\n'), [['від', 'до', 'ціна'], ['0', '25', '6,4']])

    def test_google_export_url(self):
        url = 'https://docs.google.com/spreadsheets/d/AbC-123_x/edit#gid=777'
        self.assertEqual(google_export_url(url),
                         'https://docs.google.com/spreadsheets/d/AbC-123_x/export?format=csv&gid=777')
        with self.assertRaises(SheetImportError):
            google_export_url('https://example.com/spreadsheets/d/AbC')


class TariffImportViewTests(TestCase):
    def setUp(self):
        user = get_user_model().objects.create_user(username='sup', email='sup@example.com', password='x')
        user.groups.add(Group.objects.get_or_create(name='Supervisors')[0])
        self.client.force_login(user)
        TransportTariff.objects.create(km_from=0, km_to=100, price_per_ton_km=Decimal('5'))
        TransportTariff.objects.create(km_from=101, km_to=500, price_per_ton_km=Decimal('4'))

    def upload(self, text):
        return self.client.post(reverse('pricing:tariff_import'),
                                {'file': SimpleUploadedFile('t.csv', text.encode(), content_type='text/csv')})

    def test_table_is_fully_replaced(self):
        response = self.upload('від,до,ціна\n0,25,32\n26,50,18\n51,1000,6.4\n')
        self.assertRedirects(response, reverse('pricing:tariff_list'), fetch_redirect_response=False)
        self.assertEqual(list(TransportTariff.objects.values_list('km_from', 'km_to', 'price_per_ton_km')),
                         [(0, 25, Decimal('32')), (26, 50, Decimal('18')), (51, 1000, Decimal('6.4'))])
        self.assertEqual(TariffImport.objects.get().old_count, 2)

    def test_invalid_table_changes_nothing(self):
        response = self.upload('0,25,32\n20,50,18\n')
        self.assertEqual(response.status_code, 400)
        self.assertEqual(TransportTariff.objects.count(), 2)
        self.assertFalse(TariffImport.objects.exists())

    @mock.patch('pricing.sheets.requests.get')
    def test_google_sheet(self, get):
        get.return_value = mock.Mock(status_code=200, headers={'Content-Type': 'text/csv'}, content=b'0,40,10\n')
        url = 'https://docs.google.com/spreadsheets/d/abc/edit#gid=0'
        self.client.post(reverse('pricing:tariff_import'), {'sheet_url': url})
        self.assertEqual(TransportTariff.objects.count(), 1)
        self.assertEqual(self.client.get(reverse('pricing:tariff_list')).context['sheet_url'], url)


class UnloadingPointImportTests(TestCase):
    HEADER = ['Назва', 'Термінал / покупець', 'Область', 'Район', 'Культура', 'Клас / специфікація', 'Ціна, грн з ПДВ/т', 'Статус']

    def setUp(self):
        user = get_user_model().objects.create_user(username='sup', email='sup@example.com', password='x')
        user.groups.add(Group.objects.get_or_create(name='Supervisors')[0])
        self.client.force_login(user)
        self.region = Region.objects.create(tripoli_region_id=1, name='Вінницька')
        self.district = District.objects.create(tripoli_district_id=1, name='Вінницький', region=self.region)
        self.wheat = CultureableName.objects.create(cultureable_name='Пшениця')
        self.corn = CultureableName.objects.create(cultureable_name='Кукурудза')
        self.kept = UnloadingPoint.objects.create(name='Вінниця Бунге', region=self.region)
        UnloadingPointPrice.objects.create(unloading_point=self.kept, culture=self.wheat, specification='2 клас',
                                           price=Decimal('9000'))
        UnloadingPointPrice.objects.create(unloading_point=self.kept, culture=self.corn, price=Decimal('8000'))
        self.removed = UnloadingPoint.objects.create(name='Старе місце', region=self.region)

    def upload(self, rows):
        text = '\n'.join(';'.join(str(c) for c in row) for row in [self.HEADER] + rows)
        return self.client.post(reverse('pricing:unloading_point_import'),
                                {'file': SimpleUploadedFile('p.csv', text.encode(), content_type='text/csv')})

    def test_points_and_prices_follow_the_table(self):
        response = self.upload([
            ['Вінниця Бунге', 'Бунге', 'Вінницька обл.', 'Вінницький р-н', 'Пшениця', '2 клас', '9 500', ''],
            ['', '', '', '', 'Пшениця', '3 клас', '', 'Стоп'],
            ['Нове місце', '', 'Вінницька', '', 'Кукурудза', '', '8100,5', 'Актуальна'],
        ])
        self.assertRedirects(response, reverse('pricing:unloading_point_list'), fetch_redirect_response=False)
        self.assertFalse(UnloadingPoint.objects.filter(id=self.removed.id).exists())
        self.kept.refresh_from_db()
        self.assertEqual((self.kept.terminal, self.kept.district), ('Бунге', self.district))
        self.assertEqual(sorted(self.kept.prices.values_list('specification', 'price', 'status')),
                         [('2 клас', Decimal('9500'), 'active'), ('3 клас', None, 'stop')])
        new = UnloadingPoint.objects.get(name='Нове місце')
        self.assertEqual(list(new.prices.values_list('culture', 'price')), [(self.corn.id, Decimal('8100.5'))])
        log = UnloadingPointImport.objects.get()
        self.assertEqual((log.created, log.updated, log.deleted), (1, 1, 1))

    def test_errors_change_nothing(self):
        response = self.upload([
            ['Вінниця Бунге', '', 'Неіснуюча', '', 'Пшениця', '', '9500', ''],
            ['Інше', '', 'Вінницька', '', 'Рис', '', '1', ''],
            ['Третє', '', 'Вінницька', '', 'Пшениця', '', '', 'Актуальна'],
        ])
        self.assertEqual(response.status_code, 400)
        errors = response.context['import_errors']
        self.assertEqual(len(errors), 3)
        self.assertTrue(UnloadingPoint.objects.filter(id=self.removed.id).exists())
        self.assertEqual(self.kept.prices.count(), 2)

    def test_export_round_trip_changes_nothing(self):
        rows = list(export_rows())
        plan = parse_points([[str(c) for c in row] for row in rows])
        result = apply_plan(plan)
        self.assertEqual((result.created, result.updated, result.deleted, result.unchanged), (0, 0, 0, 2))


class UnloadingPointMatrixImportTests(TestCase):
    HEADER = ['', 'Пшениця 2 клас', 'Ячмінь', 'Ріпак ГМО', 'Соя не ГМО', 'СОРГО', 'Термінал', '']

    def setUp(self):
        regions = ['Одеська', 'Закарпатська', 'Київська', 'Харківська', 'Івано-Франківська']
        self.regions = {name: Region.objects.create(tripoli_region_id=i, name=name) for i, name in enumerate(regions)}
        names = ['Пшениця озима', 'Пшениця яра', 'Ячмінь озимий', 'Ріпак озимий', 'Соя', 'Сорго']
        self.cultures = {name: CultureableName.objects.create(cultureable_name=name) for name in names}

    def rows(self, *rows):
        return [['Закупівельні ціни'], [], self.HEADER, *rows]

    def blank(self, name, **cells):
        columns = {'wheat': 1, 'barley': 2, 'rape': 3, 'soy': 4, 'sorghum': 5, 'terminal': 6}
        row = [name] + [''] * 7
        for key, value in cells.items():
            row[columns[key]] = value
        return row

    def test_cultures_statuses_and_regions(self):
        plan = parse_points(self.rows(
            self.blank('Киівська обл'),
            self.blank('Київ ', wheat='6400', rape='оновл.', soy='стоп', sorghum='-', terminal='Елеватор'),
            self.blank('Вигода Одеська обл'),
            self.blank('Харківська лбл'),
            self.blank('Берестин', barley=' новл. '),
            self.blank('Ів-Франківська обл'),
            self.blank('Коломия:', barley=5500.0),
            self.blank('Дунай'),
            self.blank('Рені', soy='19 000'),
            self.blank('Західні Переходи '),
            self.blank('ЧОП'),
            self.blank('Ботьово, Закарпатська обл', soy='18500'),
        ))
        by_name = {p.name: p for p in plan.points}
        self.assertEqual({n: p.region.name for n, p in by_name.items()}, {
            'Київ': 'Київська', 'Вигода Одеська обл': 'Київська', 'Берестин': 'Харківська',
            'Коломия': 'Івано-Франківська', 'Рені': 'Одеська', 'ЧОП': 'Закарпатська',
            'Ботьово, Закарпатська обл': 'Закарпатська',
        })
        self.assertFalse(plan.delete_missing)
        kyiv = by_name['Київ']
        self.assertEqual(kyiv.values, {'terminal': 'Елеватор'})
        self.assertEqual(sorted((c.cultureable_name, spec, price, status) for c, spec, price, status in kyiv.prices.values()), [
            ('Пшениця озима', '2 клас', Decimal('6400.00'), 'active'),
            ('Ріпак озимий', 'ГМО', None, 'updating'),
            ('Соя', 'не ГМО', None, 'stop'),
        ])
        self.assertEqual(list(by_name['Берестин'].prices.values())[0][3], 'updating')
        self.assertEqual(list(by_name['Коломия'].prices.values())[0][2], Decimal('5500.00'))

    def test_missing_points_stay_and_terminal_is_not_erased(self):
        region = self.regions['Київська']
        missing = UnloadingPoint.objects.create(name='Немає в таблиці', region=region)
        point = UnloadingPoint.objects.create(name='Київ', region=region, terminal='Старий', latitude=Decimal('50.1'),
                                              longitude=Decimal('30.1'))
        UnloadingPointPrice.objects.create(unloading_point=point, culture=self.cultures['Соя'], specification='не ГМО',
                                           price=Decimal('100'))
        UnloadingPointPrice.objects.create(unloading_point=missing, culture=self.cultures['Соя'], price=Decimal('100'))
        result = apply_plan(parse_points(self.rows(self.blank('Київська обл'), self.blank('київ', wheat='6400'))))
        self.assertEqual((result.created, result.updated, result.deleted), (0, 1, 0))
        self.assertEqual(result.missing_names, ['Немає в таблиці'])
        self.assertEqual(missing.prices.count(), 1)
        point.refresh_from_db()
        self.assertEqual((point.terminal, point.latitude), ('Старий', Decimal('50.100000')))
        self.assertEqual(list(point.prices.values_list('specification', 'price')), [('2 клас', Decimal('6400.00'))])

    def test_errors_are_collected(self):
        rows = self.rows(self.blank('Київська обл'), self.blank('Київ', wheat='дорого'), self.blank('Київ', wheat='1'),
                         self.blank('', soy='1'))
        rows[2] = rows[2][:7] + ['Невідома культура']
        with self.assertRaises(SheetImportError) as ctx:
            parse_points(rows)
        self.assertEqual(len(ctx.exception.errors), 4)

    def test_point_without_region_is_an_error(self):
        with self.assertRaises(SheetImportError) as ctx:
            parse_points(self.rows(self.blank('Регіони'), self.blank('Десь', wheat='1')))
        self.assertIn('область', ctx.exception.errors[0])

    def test_unrelated_table_keeps_header_error(self):
        with self.assertRaises(SheetImportError) as ctx:
            parse_points([['Щось'], ['інше']])
        self.assertIn('Не знайдено рядок заголовків', ctx.exception.errors[0])


@override_settings(DEVICE_APPROVAL_ENABLED=False)
class RoleAccessTests(TestCase):
    TARIFF_URLS = ['pricing:tariff_list', 'pricing:tariff_export']

    def user(self, *groups):
        user = get_user_model().objects.create_user(username='u', email='u@example.com', password='x')
        for name in groups:
            user.groups.add(Group.objects.get_or_create(name=name)[0])
        self.client.force_login(user)
        return user

    def post_tariffs(self):
        return self.client.post(reverse('pricing:tariff_import'),
                                {'file': SimpleUploadedFile('t.csv', b'0,25,32\n', content_type='text/csv')})

    def assert_tariffs_editable(self):
        for name in self.TARIFF_URLS:
            self.assertEqual(self.client.get(reverse(name)).status_code, 200, name)
        self.assertEqual(self.post_tariffs().status_code, 302)
        self.assertEqual(TransportTariff.objects.count(), 1)

    def assert_unloading_points(self, status):
        self.assertEqual(self.client.get(reverse('pricing:unloading_point_list')).status_code, status)
        self.assertEqual(self.client.get(reverse('pricing:unloading_point_create')).status_code, status)

    def test_migration_creates_group(self):
        # У тестах міграції вимкнені (TEST.MIGRATE = False), тому викликаємо її функцію напряму
        import_module('pricing.migrations.0008_logists_group').create_group(apps, None)
        self.assertTrue(Group.objects.filter(name='Logists').exists())

    def test_logist_edits_tariffs_but_not_unloading_points(self):
        self.user('Logists')
        self.assert_tariffs_editable()
        self.assert_unloading_points(403)

    def test_supervisor_edits_tariffs_and_unloading_points(self):
        self.user('Supervisors')
        self.assert_tariffs_editable()
        self.assert_unloading_points(200)

    def test_manager_edits_neither(self):
        self.user('Managers')
        for name in self.TARIFF_URLS:
            self.assertEqual(self.client.get(reverse(name)).status_code, 403, name)
        self.assertEqual(self.post_tariffs().status_code, 403)
        self.assertFalse(TransportTariff.objects.exists())
        self.assert_unloading_points(403)

    def test_logist_is_limited_to_tariffs(self):
        self.user('Logists')
        self.assertRedirects(self.client.get('/'), reverse('pricing:tariff_list'))
        for name in ['dataapp:farmers_list', 'dataapp:export_farmers_xlsx', 'dataapp:add_farmer',
                     'contacts:contact_person_list', 'crm:interaction_list', 'pricing:cost_calculator',
                     'security:login_log']:
            self.assertEqual(self.client.get(reverse(name)).status_code, 403, name)
        self.assertEqual(self.client.get(reverse('account_change_password')).status_code, 200)

    def test_logist_menu_shows_only_tariffs(self):
        self.user('Logists')
        response = self.client.get(reverse('pricing:tariff_list'))
        self.assertContains(response, 'Тарифи перевезення')
        for title in ['Фермери', 'Контакти', 'Місця розвантаження', 'Журнал входів']:
            self.assertNotContains(response, title)

    def test_logist_with_manager_role_keeps_manager_access(self):
        self.user('Logists', 'Managers')
        self.assertEqual(self.client.get(reverse('dataapp:farmers_list')).status_code, 200)
        self.assert_tariffs_editable()


class CalculatorNegativeValuesTests(TestCase):
    def render(self, cpt, transport, desired):
        user = get_user_model().objects.create_user(username='sup', email='sup@example.com', password='x')
        user.groups.add(Group.objects.get_or_create(name='Supervisors')[0])
        self.client.force_login(user)
        region = Region.objects.create(tripoli_region_id=1, name='Одеська')
        point = UnloadingPoint.objects.create(name='Порт', region=region)
        culture = CultureableName.objects.create(cultureable_name='Пшениця')
        price = UnloadingPointPrice.objects.create(unloading_point=point, culture=culture, price=Decimal(cpt))
        margin = Decimal(cpt) - Decimal(desired) - Decimal(transport)
        option = RouteOption(price=price, distance_km=Decimal('100'), duration_min=90, rate=Decimal('5'),
                             transport_per_ton=Decimal(transport), margin_per_ton=margin, profit_total=margin * 10)
        query = {'culture': culture.id, 'price': desired, 'tons': 10, 'settlement': '|Вінниця'}
        with mock.patch('pricing.views.calculate', return_value=Calculation(options=[option])):
            return self.client.get(reverse('pricing:cost_calculator'), query)

    def test_negative_values_are_red(self):
        response = self.render(cpt='100', transport='150', desired='100')
        self.assertTrue(response.context['calculation'])
        # Відхилення в блоці найвигіднішого і в таблиці, ціна FCA в таблиці
        self.assertContains(response, 'calc-best-value calc-negative')
        self.assertContains(response, 'class="num calc-negative"', count=2)

    def test_positive_values_stay_regular(self):
        response = self.render(cpt='9000', transport='500', desired='8000')
        self.assertTrue(response.context['calculation'])
        self.assertNotContains(response, 'calc-negative')
