import re
from datetime import timedelta
from unittest import mock

from allauth.account.models import EmailAddress
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.core import mail
from django.test import RequestFactory, SimpleTestCase, TestCase, override_settings
from django.urls import reverse
from django.utils import timezone

from contacts.models import ContactPerson
from crm.cron_jobs import BirthdayCronJob, ReminderCronJob
from crm.dashboard import tasks_of
from crm.forms import InteractionForm
from crm.models import Interaction
from farmerapp.models import Farmer, Region
from .models import ActiveSession, LoginEvent, TrustedDevice
from .utils import client_ip

PASSWORD = 'secret-pass-123'


def make_user(email, group):
    user = get_user_model().objects.create_user(username=email, email=email, password=PASSWORD)
    user.groups.add(Group.objects.get_or_create(name=group)[0])
    return user


@override_settings(DEVICE_APPROVAL_ENABLED=False)
class SingleSessionTests(TestCase):
    def setUp(self):
        self.manager = make_user('manager@example.com', 'Managers')
        self.supervisor = make_user('supervisor@example.com', 'Supervisors')
        self.page = reverse('pricing:cost_calculator')

    def login(self, email):
        client = self.client_class()
        response = client.post(reverse('account_login'), {'login': email, 'password': PASSWORD})
        self.assertEqual(response.status_code, 302)
        return client

    def test_new_login_displaces_previous_manager_session(self):
        first = self.login(self.manager.email)
        self.assertEqual(first.get(self.page).status_code, 200)
        second = self.login(self.manager.email)

        response = first.get(self.page)
        self.assertRedirects(response, reverse('account_login'), fetch_redirect_response=False)
        self.assertEqual(second.get(self.page).status_code, 200)
        self.assertTrue(LoginEvent.objects.filter(user=self.manager, kind='displaced').exists())
        self.assertFalse(LoginEvent.objects.filter(user=self.manager, kind='logout').exists())
        # Витіснений браузер справді вийшов, а не лише отримав редирект
        self.assertNotEqual(first.get(self.page).status_code, 200)

    def test_supervisor_may_use_several_browsers(self):
        first = self.login(self.supervisor.email)
        second = self.login(self.supervisor.email)
        self.assertEqual(first.get(self.page).status_code, 200)
        self.assertEqual(second.get(self.page).status_code, 200)

    def test_failed_login_is_logged(self):
        self.client.post(reverse('account_login'), {'login': self.manager.email, 'password': 'wrong'})
        self.assertTrue(LoginEvent.objects.filter(kind='failed', email=self.manager.email).exists())

    def test_login_log_only_for_supervisors(self):
        url = reverse('security:login_log')
        self.assertEqual(self.login(self.manager.email).get(url).status_code, 403)
        response = self.login(self.supervisor.email).get(url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.manager.email)


class ClientIpTests(SimpleTestCase):
    def ip(self, remote, forwarded=None):
        extra = {'HTTP_X_FORWARDED_FOR': forwarded} if forwarded is not None else {}
        return client_ip(RequestFactory().get('/', REMOTE_ADDR=remote, **extra))

    def test_reads_address_added_by_own_proxy(self):
        self.assertEqual(self.ip('127.0.0.1', '8.8.8.8, 10.0.0.1'), '8.8.8.8')

    def test_value_sent_by_client_is_ignored(self):
        # Клієнт надіслав 1.1.1.1, а проксі дописав справжню адресу праворуч
        self.assertEqual(self.ip('127.0.0.1', '1.1.1.1, 8.8.8.8'), '8.8.8.8')

    def test_header_is_ignored_without_proxy(self):
        self.assertEqual(self.ip('8.8.4.4', '1.1.1.1'), '8.8.4.4')

    def test_garbage_does_not_break_anything(self):
        self.assertEqual(self.ip('127.0.0.1', 'not-an-ip'), '127.0.0.1')
        self.assertIsNone(self.ip('garbage'))


class LoginWithBadHeaderTests(TestCase):
    def test_garbage_forwarded_for_does_not_break_login(self):
        make_user('sup@example.com', 'Supervisors')
        response = self.client.post(reverse('account_login'), {'login': 'sup@example.com', 'password': PASSWORD},
                                    HTTP_X_FORWARDED_FOR='not-an-ip')
        self.assertEqual(response.status_code, 302)


class DeviceApprovalTests(TestCase):
    def setUp(self):
        self.manager = make_user('manager@example.com', 'Managers')
        self.logist = make_user('logist@example.com', 'Logists')
        self.supervisor = make_user('supervisor@example.com', 'Supervisors')
        self.page = reverse('pricing:cost_calculator')
        self.pending_url = reverse('security:device_pending')

    def login(self, email):
        client = self.client_class()
        client.post(reverse('account_login'), {'login': email, 'password': PASSWORD})
        return client

    def decide(self, device, action, by=None):
        client = by or self.login(self.supervisor.email)
        return client.post(reverse('security:device_decide', args=[device.id]), {'action': action})

    def approved_client(self, email):
        client = self.login(email)
        client.get(self.page)
        self.decide(TrustedDevice.objects.get(user__email=email, status='pending'), 'approve')
        return client

    def test_new_device_waits_and_supervisors_are_notified(self):
        client = self.login(self.manager.email)
        self.assertRedirects(client.get(self.page), self.pending_url, fetch_redirect_response=False)
        self.assertRedirects(client.get(reverse('dataapp:export_farmers_xlsx')), self.pending_url,
                             fetch_redirect_response=False)
        self.assertContains(client.get(self.pending_url), 'Очікуємо підтвердження')
        device = TrustedDevice.objects.get(user=self.manager)
        self.assertEqual(device.status, 'pending')
        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].to, [self.supervisor.email])
        self.assertTrue(LoginEvent.objects.filter(user=self.manager, kind='device_new').exists())

    def test_token_is_stored_only_as_hash(self):
        client = self.login(self.manager.email)
        client.get(self.page)
        cookie = client.cookies['trusted_device']
        self.assertTrue(cookie['httponly'])
        self.assertNotEqual(TrustedDevice.objects.get(user=self.manager).token_hash, cookie.value)

    def test_approved_device_works_and_survives_new_login(self):
        client = self.approved_client(self.manager.email)
        self.assertEqual(client.get(self.page).status_code, 200)
        client.post(reverse('account_logout'))
        client.post(reverse('account_login'), {'login': self.manager.email, 'password': PASSWORD})
        self.assertEqual(client.get(self.page).status_code, 200)
        self.assertEqual(TrustedDevice.objects.filter(user=self.manager).count(), 1)

    def test_revoked_device_is_blocked_immediately(self):
        client = self.approved_client(self.manager.email)
        self.decide(TrustedDevice.objects.get(user=self.manager), 'reject')
        self.assertRedirects(client.get(self.page), self.pending_url, fetch_redirect_response=False)
        self.assertContains(client.get(self.pending_url), 'Пристрій заблоковано')

    def test_unapproved_login_does_not_displace_working_session(self):
        worker = self.approved_client(self.manager.email)
        worker.get(self.page)
        stranger = self.login(self.manager.email)
        stranger.get(self.page)
        self.assertEqual(worker.get(self.page).status_code, 200)
        self.assertRedirects(stranger.get(self.page), self.pending_url, fetch_redirect_response=False)
        self.assertFalse(LoginEvent.objects.filter(kind='displaced').exists())

    def test_session_takes_over_once_its_device_is_approved(self):
        first = self.approved_client(self.manager.email)
        first.get(self.page)
        second = self.login(self.manager.email)
        second.get(self.page)
        self.decide(TrustedDevice.objects.get(user=self.manager, status='pending'), 'approve')
        self.assertEqual(second.get(self.page).status_code, 200)
        self.assertRedirects(first.get(self.page), reverse('account_login'), fetch_redirect_response=False)

    def test_supervisor_needs_no_approval_and_manager_cannot_decide(self):
        client = self.login(self.supervisor.email)
        self.assertEqual(client.get(self.page).status_code, 200)
        self.assertFalse(TrustedDevice.objects.filter(user=self.supervisor).exists())

        manager = self.approved_client(self.manager.email)
        self.assertEqual(manager.get(reverse('security:devices')).status_code, 403)
        other = self.login(self.logist.email)
        other.get(reverse('account_change_password'))
        device = TrustedDevice.objects.get(user=self.logist)
        self.assertEqual(self.decide(device, 'approve', by=manager).status_code, 403)
        device.refresh_from_db()
        self.assertEqual(device.status, 'pending')

    def test_waiting_user_cannot_approve_own_device(self):
        client = self.login(self.manager.email)
        client.get(self.page)
        device = TrustedDevice.objects.get(user=self.manager)
        self.decide(device, 'approve', by=client)
        device.refresh_from_db()
        self.assertEqual(device.status, 'pending')

    def test_devices_page_and_menu_for_supervisor(self):
        self.login(self.manager.email).get(self.page)
        response = self.login(self.supervisor.email).get(reverse('security:devices'))
        self.assertContains(response, self.manager.email)
        self.assertEqual(response.context['pending_devices_count'], 1)

    def test_logist_also_gets_single_session(self):
        first = self.approved_client(self.logist.email)
        first.get(reverse('pricing:tariff_list'))
        self.assertTrue(ActiveSession.objects.filter(user=self.logist).exists())
        second = self.login(self.logist.email)
        second.get(reverse('pricing:tariff_list'))
        self.decide(TrustedDevice.objects.get(user=self.logist, status='pending'), 'approve')
        self.assertEqual(second.get(reverse('pricing:tariff_list')).status_code, 200)
        self.assertRedirects(first.get(reverse('pricing:tariff_list')), reverse('account_login'),
                             fetch_redirect_response=False)


class SignupClosedTests(TestCase):
    def test_nobody_can_register(self):
        data = {'email': 'stranger@example.com', 'username': 'stranger',
                'password1': 'Zx9!kdlqpW2', 'password2': 'Zx9!kdlqpW2'}
        self.assertEqual(self.client.post(reverse('account_signup'), data).status_code, 200)
        self.assertFalse(get_user_model().objects.filter(email='stranger@example.com').exists())
        self.assertTemplateUsed(self.client.get(reverse('account_signup')), 'account/signup_closed.html')


@override_settings(DEVICE_APPROVAL_ENABLED=False)
class TeamManagementTests(TestCase):
    def setUp(self):
        self.supervisor = make_user('supervisor@example.com', 'Supervisors')
        self.manager = make_user('manager@example.com', 'Managers')
        self.client.force_login(self.supervisor)
        self.list_url = reverse('security:team_list')
        self.create_url = reverse('security:team_member_create')

    def data(self, email='new@example.com', roles=('Managers',)):
        return {'first_name': 'Нова', 'last_name': 'Людина', 'email': email, 'roles': list(roles)}

    def remove(self, user, recipient=None):
        data = {'recipient': recipient.id} if recipient else {}
        return self.client.post(reverse('security:team_member_remove', args=[user.id]), data)

    def roles(self, user):
        return set(user.groups.values_list('name', flat=True))

    def test_only_supervisors_have_access(self):
        for email, group in [('m2@example.com', 'Managers'), ('l2@example.com', 'Logists')]:
            self.client.force_login(make_user(email, group))
            self.assertEqual(self.client.get(self.list_url).status_code, 403)
            self.assertEqual(self.client.post(self.create_url, self.data('x@example.com')).status_code, 403)
            self.assertEqual(self.remove(self.manager).status_code, 403)
        self.assertFalse(get_user_model().objects.filter(email='x@example.com').exists())
        self.manager.refresh_from_db()
        self.assertTrue(self.manager.is_active)

    def test_new_user_sets_password_by_link_and_logs_in(self):
        response = self.client.post(self.create_url, self.data(' New@Example.com ', ['Logists']))
        self.assertRedirects(response, self.list_url, fetch_redirect_response=False)
        user = get_user_model().objects.get(email='new@example.com')
        self.assertEqual(self.roles(user), {'Logists'})
        self.assertFalse(user.has_usable_password())
        self.assertTrue(LoginEvent.objects.filter(kind='user_created', user=self.supervisor).exists())

        self.assertEqual(mail.outbox[-1].to, ['new@example.com'])
        link = re.search(r'https?://\S+', mail.outbox[-1].body).group()
        visitor = self.client_class()
        form_page = visitor.get(link)
        self.assertEqual(form_page.status_code, 302)
        password = 'Zx9!kdlqpW2'
        visitor.post(form_page.url, {'password1': password, 'password2': password})
        user.refresh_from_db()
        self.assertTrue(user.check_password(password))
        login = visitor.post(reverse('account_login'), {'login': 'new@example.com', 'password': password})
        self.assertEqual(login.status_code, 302)
        self.assertEqual(visitor.get(reverse('pricing:tariff_list')).status_code, 200)

    def test_failed_mail_keeps_user_and_tells_supervisor(self):
        with mock.patch('security.utils.send_mail', side_effect=OSError):
            response = self.client.post(self.create_url, self.data(), follow=True)
        self.assertTrue(get_user_model().objects.filter(email='new@example.com').exists())
        self.assertContains(response, 'Не вдалося надіслати лист')

    def test_form_validation(self):
        for data in [self.data(self.manager.email.upper()), self.data(roles=()), {**self.data(), 'first_name': ''}]:
            self.assertEqual(self.client.post(self.create_url, data).status_code, 200)
        self.assertFalse(get_user_model().objects.filter(email='new@example.com').exists())

    def test_supervisor_role_cannot_be_granted(self):
        response = self.client.post(self.create_url, self.data(roles=['Supervisors']))
        self.assertEqual(response.status_code, 200)
        url = reverse('security:team_member_edit', args=[self.manager.id])
        self.client.post(url, self.data(self.manager.email, ['Supervisors', 'Managers']))
        self.assertEqual(self.roles(self.manager), {'Managers'})

    def test_changing_roles_takes_effect_and_is_logged(self):
        other = Group.objects.create(name='Other')
        self.manager.groups.add(other)
        url = reverse('security:team_member_edit', args=[self.manager.id])
        self.client.post(url, self.data(self.manager.email, ['Logists']))
        self.assertEqual(self.roles(self.manager), {'Logists', 'Other'})
        event = LoginEvent.objects.get(kind='user_changed')
        self.assertIn('Менеджер → Логіст', event.detail)

        browser = self.client_class()
        browser.force_login(self.manager)
        self.assertEqual(browser.get(reverse('pricing:tariff_list')).status_code, 200)
        self.assertEqual(browser.get(reverse('dataapp:farmers_list')).status_code, 403)

    def test_changing_email_updates_login(self):
        EmailAddress.objects.create(user=self.manager, email=self.manager.email, primary=True, verified=True)
        url = reverse('security:team_member_edit', args=[self.manager.id])
        self.client.post(url, self.data('renamed@example.com'))
        self.assertEqual(list(EmailAddress.objects.filter(user=self.manager).values_list('email', flat=True)),
                         ['renamed@example.com'])
        browser = self.client_class()
        response = browser.post(reverse('account_login'), {'login': 'renamed@example.com', 'password': PASSWORD})
        self.assertEqual(response.status_code, 302)

    def test_protected_accounts_cannot_be_touched(self):
        other_supervisor = make_user('s2@example.com', 'Supervisors')
        staff = make_user('staff@example.com', 'Managers')
        staff.is_staff = True
        staff.save()
        for target in [self.supervisor, other_supervisor, staff]:
            self.assertEqual(self.client.get(reverse('security:team_member_edit', args=[target.id])).status_code, 404)
            self.assertEqual(self.remove(target).status_code, 404)
            target.refresh_from_db()
            self.assertTrue(target.is_active)
        self.assertNotContains(self.client.get(self.list_url), 's2@example.com')

    def test_remove_closes_access_keeps_history_and_can_be_restored(self):
        farmer = Farmer.objects.create(name='Ф', region=Region.objects.create(tripoli_region_id=1, name='В'))
        interaction = Interaction.objects.create(farmer=farmer, user=self.manager, price=0)
        browser = self.client_class()
        browser.post(reverse('account_login'), {'login': self.manager.email, 'password': PASSWORD})
        page = reverse('pricing:cost_calculator')
        self.assertEqual(browser.get(page).status_code, 200)

        self.remove(self.manager, self.supervisor)
        self.assertRedirects(browser.get(page), f"{reverse('account_login')}?next={page}", fetch_redirect_response=False)
        blocked = self.client_class()
        blocked.post(reverse('account_login'), {'login': self.manager.email, 'password': PASSWORD})
        self.assertNotEqual(blocked.get(page).status_code, 200)
        self.assertTrue(Interaction.objects.filter(pk=interaction.pk).exists())
        self.assertContains(self.client.get(self.list_url), 'Відновити')
        self.assertTrue(LoginEvent.objects.filter(kind='user_removed', detail=self.manager.email).exists())

        self.client.post(reverse('security:team_member_restore', args=[self.manager.id]))
        again = self.client_class()
        again.post(reverse('account_login'), {'login': self.manager.email, 'password': PASSWORD})
        self.assertEqual(again.get(page).status_code, 200)

    def test_removed_manager_cannot_be_assigned_tasks(self):
        self.remove(self.manager)
        form = InteractionForm(user=self.supervisor)
        self.assertNotIn(self.manager, form.fields['assigned_to'].queryset)


@override_settings(DEVICE_APPROVAL_ENABLED=False)
class WorkTransferTests(TestCase):
    def setUp(self):
        self.supervisor = make_user('supervisor@example.com', 'Supervisors')
        self.old = make_user('old@example.com', 'Managers')
        self.new = make_user('new@example.com', 'Managers')
        self.other = make_user('other@example.com', 'Managers')
        self.logist = make_user('logist@example.com', 'Logists')
        region = Region.objects.create(tripoli_region_id=1, name='В')
        self.farmer = Farmer.objects.create(name='Переданий', region=region, client_status='hot')
        self.foreign = Farmer.objects.create(name='Сторонній', region=region, client_status='hot')
        tomorrow = timezone.now() + timedelta(days=1)
        self.history = Interaction.objects.create(farmer=self.farmer, user=self.old, price=0)
        self.task = Interaction.objects.create(farmer=self.farmer, user=self.old, price=0, next_interaction_date=tomorrow,
                                               reminder_sent_at=timezone.now())
        self.foreign_task = Interaction.objects.create(farmer=self.foreign, user=self.other, price=0,
                                                       next_interaction_date=tomorrow)
        self.client.force_login(self.supervisor)
        self.url = reverse('security:team_member_remove', args=[self.old.id])

    def test_cannot_remove_without_recipient(self):
        self.assertContains(self.client.get(self.url), 'Кому передати')
        response = self.client.post(self.url, {})
        self.assertContains(response, 'Оберіть, кому передати')
        self.old.refresh_from_db()
        self.assertTrue(self.old.is_active)

    def test_invalid_recipients_are_rejected(self):
        for recipient in [self.old, self.logist]:
            self.assertEqual(self.client.post(self.url, {'recipient': recipient.id}).status_code, 200)
        self.new.is_active = False
        self.new.save()
        self.assertEqual(self.client.post(self.url, {'recipient': self.new.id}).status_code, 200)
        self.old.refresh_from_db()
        self.assertTrue(self.old.is_active)
        self.assertEqual(tasks_of(self.old).count(), 1)

    def test_transfer_moves_tasks_and_farmers_and_keeps_authors(self):
        response = self.client.post(self.url, {'recipient': self.new.id}, follow=True)
        self.assertContains(response, 'задач: 1, фермерів: 1')
        self.old.refresh_from_db()
        self.assertFalse(self.old.is_active)
        self.assertEqual(list(tasks_of(self.new)), [self.task])
        self.assertFalse(tasks_of(self.old).exists())
        self.task.refresh_from_db()
        self.history.refresh_from_db()
        self.assertEqual((self.task.user, self.history.user), (self.old, self.old))
        self.assertEqual((self.task.assigned_to, self.history.assigned_to), (self.new, self.new))
        self.assertIsNone(self.task.reminder_sent_at)
        self.foreign_task.refresh_from_db()
        self.assertIsNone(self.foreign_task.assigned_to)
        self.assertEqual(LoginEvent.objects.get(kind='work_transferred').detail,
                         'old@example.com → new@example.com: задач 1, фермерів 1')

    def test_new_manager_gets_farmer_with_full_history(self):
        url = reverse('dataapp:farmer_general_info', args=[self.farmer.id])
        browser = self.client_class()
        browser.force_login(self.new)
        self.assertEqual(browser.get(url).status_code, 403)
        self.client.post(self.url, {'recipient': self.new.id})
        response = browser.get(url)
        self.assertEqual(len(response.context['interactions']), 2)
        self.assertContains(browser.get(reverse('dataapp:farmers_list')), 'Переданий')
        self.assertContains(browser.get(reverse('crm:reminders')), 'Переданий')

    def test_task_assigned_to_someone_else_stays_there(self):
        self.task.assigned_to = self.other
        self.task.save()
        self.client.post(self.url, {'recipient': self.new.id})
        self.task.refresh_from_db()
        self.assertEqual(self.task.assigned_to, self.other)

    def test_supervisor_can_be_recipient(self):
        self.client.post(self.url, {'recipient': self.supervisor.id})
        self.assertEqual(list(tasks_of(self.supervisor)), [self.task])

    def test_without_work_removal_needs_no_recipient(self):
        url = reverse('security:team_member_remove', args=[self.logist.id])
        self.assertNotContains(self.client.get(url), 'Кому передати')
        self.client.post(url, {})
        self.logist.refresh_from_db()
        self.assertFalse(self.logist.is_active)
        self.assertFalse(LoginEvent.objects.filter(kind='work_transferred').exists())

    def test_work_of_already_removed_user_can_be_transferred(self):
        self.old.is_active = False
        self.old.save()
        self.assertContains(self.client.get(reverse('security:team_list')), 'Передати')
        self.client.post(self.url, {'recipient': self.new.id})
        self.assertEqual(list(tasks_of(self.new)), [self.task])
        self.assertFalse(LoginEvent.objects.filter(kind='user_removed').exists())

    def test_removed_user_gets_no_reminders(self):
        self.task.next_interaction_date = timezone.now() + timedelta(minutes=5)
        self.task.reminder_sent_at = None
        self.task.save()
        self.old.is_active = False
        self.old.save()
        ReminderCronJob().do()
        self.assertNotIn(self.old.email, [address for message in mail.outbox for address in message.to])


class BirthdayMailTests(TestCase):
    def test_logist_only_gets_no_contact_birthdays(self):
        ContactPerson.objects.create(name='Іван', surname='Петренко', birth_date=timezone.localdate())
        make_user('manager@example.com', 'Managers')
        make_user('both@example.com', 'Managers').groups.add(Group.objects.get_or_create(name='Logists')[0])
        make_user('logist@example.com', 'Logists')
        BirthdayCronJob().do()
        self.assertEqual({message.to[0] for message in mail.outbox}, {'manager@example.com', 'both@example.com'})
