"""
End-to-end flow tests for the admin and staff panels.

Run:  python manage.py test NexusApp
(Django 4.2 supports Python 3.8 - 3.12.)
"""
import copy
import os
import sys
from datetime import timedelta, time
from decimal import Decimal

from django.core.management import call_command
from django.test import TestCase
from django.urls import reverse
from django.utils import timezone

from NexusApp.models import (
    AdminUser, AttendanceMaster, Customer, Loan, LoanPayment, Place, Staff, StaffCheckIn,
)
from NexusApp.utils.crypto import encrypt_password

XHR = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}

if sys.version_info >= (3, 14):
    # Django 4.2's test client copies template contexts with copy(super()),
    # which Python 3.14 no longer allows. Production runs on 3.12; this only
    # lets the suite also run on a 3.14 dev machine.
    from django.template.context import BaseContext

    def _base_context_copy(self):
        duplicate = BaseContext.__new__(self.__class__)
        duplicate.__dict__ = copy.copy(self.__dict__)
        duplicate.dicts = self.dicts[:]
        return duplicate

    BaseContext.__copy__ = _base_context_copy

DEVNULL = open(os.devnull, 'w')


def make_loan(place, staff=None, aadhaar='111122223333', dues=10, due=Decimal('1000'),
              ptype='daily', days_ago=5, name='Test Customer'):
    today = timezone.localdate()
    customer = Customer.objects.create(
        customer_name=name, phone_number='9000000001', address='1, Main Road',
        aadhaar_number=aadhaar, referral_name='Ref', referral_phone='9000000002')
    return Loan.objects.create(
        customer=customer, place=place, staff=staff, loan_date=today - timedelta(days=days_ago),
        loan_amount=due * dues - 1000, payment_type=ptype,
        first_due_date=today - timedelta(days=days_ago - 1), number_of_dues=dues, due_amount=due,
        notes='test')


class BaseFlow(TestCase):
    @classmethod
    def setUpTestData(cls):
        call_command('admin_seeder', stdout=DEVNULL)
        cls.north = Place.objects.create(name='North')
        cls.south = Place.objects.create(name='South')
        cls.staff = Staff.objects.create(
            name='Agent One', phone='9876500001', gender='male', employee_id='EMP900',
            joining_date=timezone.localdate(), salary=Decimal('15000'), email='agent.one@test.in',
            password=encrypt_password('Agent@123'), status='Active', address='addr')
        cls.staff.places.set([cls.north])
        cls.north_loan = make_loan(cls.north, cls.staff, aadhaar='111100001111', name='North Cust')
        cls.south_loan = make_loan(cls.south, None, aadhaar='222200002222', name='South Cust')

    def admin_login(self):
        r = self.client.post(reverse('admin:login_validate'),
                             {'email': 'admin@gmail.com', 'password': 'admin'})
        self.assertEqual(r.status_code, 200, r.content)

    def staff_login(self, email='agent.one@test.in', password='Agent@123'):
        r = self.client.post(reverse('staff:staff_login_validate'),
                             {'email': email, 'password': password})
        return r


class AuthTests(BaseFlow):
    def test_admin_pages_require_login(self):
        r = self.client.get(reverse('admin:dashboard'))
        self.assertRedirects(r, reverse('admin:admin_login'))
        r = self.client.get(reverse('admin:view_staff'), **XHR)
        self.assertEqual(r.status_code, 401)

    def test_admin_login_wrong_password(self):
        r = self.client.post(reverse('admin:login_validate'),
                             {'email': 'admin@gmail.com', 'password': 'nope'})
        self.assertEqual(r.status_code, 400)

    def test_admin_login_and_logout(self):
        self.admin_login()
        self.assertEqual(self.client.get(reverse('admin:dashboard')).status_code, 200)
        self.client.get(reverse('admin:admin_logout'))
        self.assertEqual(self.client.get(reverse('admin:dashboard')).status_code, 302)

    def test_staff_login_and_inactive_block(self):
        self.assertEqual(self.staff_login().status_code, 200)
        self.assertEqual(self.client.get(reverse('staff:dashboard')).status_code, 200)
        Staff.objects.filter(pk=self.staff.pk).update(status='Inactive')
        # existing session dies and new login is refused
        self.assertEqual(self.client.get(reverse('staff:dashboard')).status_code, 302)
        self.assertEqual(self.staff_login().status_code, 403)

    def test_admin_cookie_is_not_staff_cookie(self):
        self.admin_login()
        self.assertEqual(self.client.get(reverse('staff:dashboard')).status_code, 302)

    def test_auth_cookie_not_secure_over_http(self):
        r = self.client.post(reverse('admin:login_validate'),
                             {'email': 'admin@gmail.com', 'password': 'admin'})
        self.assertFalse(r.cookies['access_token']['secure'])


class StaffManagementTests(BaseFlow):
    def setUp(self):
        self.admin_login()

    def test_add_staff_with_locations_then_login(self):
        r = self.client.post(reverse('admin:storestaff'), {
            'name': 'New Agent', 'phone': '9123456789', 'gender': 'female',
            'date_of_birth': '1995-05-05', 'address': 'Somewhere', 'joining_date': '2026-01-01',
            'salary': '12000', 'email': 'new.agent@test.in', 'password': 'Secret@123',
            'places': [self.north.id, self.south.id],
        })
        self.assertEqual(r.status_code, 200, r.content)
        staff = Staff.objects.get(email='new.agent@test.in')
        self.assertEqual(set(staff.places.values_list('name', flat=True)), {'North', 'South'})
        self.assertEqual(staff.employee_id, 'EMP901')
        # admin can view the password, staff can log in with it
        r = self.client.post(reverse('admin:view_staff_password'), {'id': staff.id})
        self.assertEqual(r.json()['password'], 'Secret@123')
        self.client.cookies.clear()
        self.assertEqual(self.staff_login('new.agent@test.in', 'Secret@123').status_code, 200)

    def test_add_staff_validation(self):
        r = self.client.post(reverse('admin:storestaff'), {'name': '', 'email': 'bad'})
        self.assertEqual(r.status_code, 400)
        self.assertIn('phone', r.json()['errors'])

    def test_update_staff_locations_and_status(self):
        r = self.client.post(reverse('admin:update_staff', args=[self.staff.id]), {
            'name': 'Agent One', 'phone': '9876500001', 'gender': 'male',
            'date_of_birth': '1990-01-01', 'address': 'addr', 'joining_date': '2026-01-01',
            'salary': '15000', 'email': 'agent.one@test.in', 'password': '',
            'places': [self.south.id],
        })
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(list(self.staff.places.values_list('name', flat=True)), ['South'])
        r = self.client.post(reverse('admin:update_staff_status'), {'id': self.staff.id, 'status': 'inactive'})
        self.assertEqual(r.json()['new_status'], 'Inactive')

    def test_staff_list_and_collection_details(self):
        LoanPayment.objects.create(loan=self.north_loan, payment_date=timezone.localdate(),
                                   amount=Decimal('1000'), collected_by=self.staff)
        r = self.client.get(reverse('admin:view_staff'), **XHR)
        row = r.json()['data'][0]
        self.assertIn('North', row['staff_details'])
        r = self.client.get(reverse('admin:staff_collection_data') + f'?id={self.staff.id}')
        data = r.json()['data']
        self.assertEqual(len(data), 1)
        self.assertEqual(data[0]['paid_due_amount'], 1000.0)


class LoanFlowTests(BaseFlow):
    loan_post = {
        'phone_number': '9555544444', 'place': 'North', 'customer_name': 'Kamala',
        'address': '5, Temple Street', 'aadhaar_number': '987654321098',
        'referral_name': 'Ravi', 'referral_phone': '9444433333',
        'loan_date': '2026-11-01', 'loan_amount': '10000', 'payment_type': 'weekly',
        'first_due_date': '2026-11-09', 'number_of_dues': '12', 'due_amount': '1000',
        'notes': 'weekly loan',
    }

    def test_admin_add_loan_creates_customer_and_place(self):
        self.admin_login()
        post = dict(self.loan_post, place='Brand New Town')
        # place must come from the saved places list
        r = self.client.post(reverse('admin:addloan'), post)
        self.assertEqual(r.status_code, 400)
        self.assertIn('place', r.json()['errors'])
        Place.objects.create(name='Brand New Town')
        r = self.client.post(reverse('admin:addloan'), post)
        self.assertEqual(r.status_code, 200, r.content)
        loan = Loan.objects.get(customer__aadhaar_number='987654321098')
        self.assertEqual(loan.total_payable, Decimal('12000'))
        self.assertEqual(loan.place.name, 'Brand New Town')
        # second loan for the same Aadhaar reuses the customer
        self.client.post(reverse('admin:addloan'), post)
        self.assertEqual(Customer.objects.filter(aadhaar_number='987654321098').count(), 1)
        self.assertEqual(Loan.objects.filter(customer__aadhaar_number='987654321098').count(), 2)

    def test_add_loan_validation(self):
        self.admin_login()
        r = self.client.post(reverse('admin:addloan'), dict(self.loan_post, aadhaar_number='12',
                                                            first_due_date='2026-10-01'))
        errors = r.json()['errors']
        self.assertIn('aadhaar_number', errors)
        self.assertIn('first_due_date', errors)

    def test_staff_add_loan_only_in_assigned_place(self):
        self.staff_login()
        r = self.client.post(reverse('staff:staff_addloan'), dict(self.loan_post, place='South'))
        self.assertEqual(r.status_code, 400)
        self.assertIn('place', r.json()['errors'])
        r = self.client.post(reverse('staff:staff_addloan'), self.loan_post)
        self.assertEqual(r.status_code, 200, r.content)
        loan = Loan.objects.get(customer__aadhaar_number='987654321098')
        self.assertEqual(loan.staff, self.staff)

    def test_admin_edit_loan(self):
        self.admin_login()
        r = self.client.get(reverse('admin:edit_loan') + f'?id={self.north_loan.id}')
        self.assertContains(r, 'Edit Loan')
        post = dict(self.loan_post, aadhaar_number=self.north_loan.customer.aadhaar_number,
                    number_of_dues='20', due_amount='500')
        r = self.client.post(reverse('admin:edit_loan') + f'?id={self.north_loan.id}', post)
        self.assertEqual(r.status_code, 200, r.content)
        self.north_loan.refresh_from_db()
        self.assertEqual(self.north_loan.total_payable, Decimal('10000'))
        self.assertEqual(self.north_loan.customer.customer_name, 'Kamala')

    def test_edit_loan_cannot_go_below_paid(self):
        self.admin_login()
        LoanPayment.objects.create(loan=self.north_loan, payment_date=timezone.localdate(),
                                   amount=Decimal('5000'))
        post = dict(self.loan_post, aadhaar_number=self.north_loan.customer.aadhaar_number,
                    number_of_dues='2', due_amount='1000')
        r = self.client.post(reverse('admin:edit_loan') + f'?id={self.north_loan.id}', post)
        self.assertEqual(r.status_code, 400)

    def test_staff_cannot_edit_other_place_loan(self):
        self.staff_login()
        r = self.client.get(reverse('staff:edit_loan') + f'?id={self.south_loan.id}')
        self.assertEqual(r.status_code, 302)


class PaymentFlowTests(BaseFlow):
    def pay(self, url, loan, amount, method='cash'):
        return self.client.post(url, {
            'loan_id': loan.id, 'payment_date': timezone.localdate().isoformat(),
            'paid_amount': str(amount), 'payment_method': method, 'payment_status': 'completed'})

    def test_staff_records_payments_until_completed(self):
        self.staff_login()
        url = reverse('staff:record_payment')
        r = self.pay(url, self.north_loan, '20000')
        self.assertEqual(r.status_code, 400)                       # more than pending
        for _ in range(9):
            self.assertEqual(self.pay(url, self.north_loan, '1000').status_code, 200)
        r = self.pay(url, self.north_loan, '1000', 'upi')
        self.assertTrue(r.json()['loan_completed'])
        self.north_loan.refresh_from_db()
        self.assertEqual(self.north_loan.status, 'completed')
        self.assertEqual(LoanPayment.objects.filter(collected_by=self.staff).count(), 10)
        self.assertEqual(self.pay(url, self.north_loan, '1').status_code, 400)  # already completed

    def test_staff_cannot_pay_other_place_loan(self):
        self.staff_login()
        r = self.pay(reverse('staff:record_payment'), self.south_loan, '1000')
        self.assertEqual(r.status_code, 404)
        self.assertFalse(LoanPayment.objects.filter(loan=self.south_loan).exists())

    def test_future_payment_date_rejected(self):
        self.admin_login()
        r = self.client.post(reverse('admin:record_payment'), {
            'loan_id': self.north_loan.id,
            'payment_date': (timezone.localdate() + timedelta(days=2)).isoformat(),
            'paid_amount': '100', 'payment_method': 'cash', 'payment_status': 'completed'})
        self.assertEqual(r.status_code, 400)

    def test_payment_history_and_invoice(self):
        self.admin_login()
        self.pay(reverse('admin:record_payment'), self.north_loan, '1500')
        r = self.client.get(reverse('admin:paid_due_history_data') + f'?id={self.north_loan.id}', **XHR)
        row = r.json()['data'][0]
        self.assertEqual(row['extra_amount'], 500.0)
        r = self.client.get(reverse('admin:payment_invoice') + f'?id={self.north_loan.id}')
        self.assertEqual(r.status_code, 200)
        r = self.client.get(reverse('admin:today_collections_data'))
        self.assertEqual(r.status_code, 200)
        self.assertIn(1500.0, [d['amount'] for d in r.json()['data']])


class StaffScopeTests(BaseFlow):
    def setUp(self):
        self.staff_login()

    def test_registers_only_show_assigned_places(self):
        r = self.client.get(reverse('staff:view_loan_request_page'), **XHR)
        names = [p['place_name'] for p in r.json()['data']]
        self.assertEqual(names, ['North'])

    def test_lists_are_scoped(self):
        r = self.client.get(reverse('staff:loan_entries_data'))
        self.assertEqual([d['place'] for d in r.json()['data']], ['North'])
        r = self.client.get(reverse('staff:loan_reports_data'), **XHR)
        self.assertEqual({d['loan_id'] for d in r.json()['data']}, {self.north_loan.id})
        r = self.client.get(reverse('staff:staff_view_all_customer'), **XHR)
        self.assertEqual([d['customer_name'] for d in r.json()['data']], ['North Cust'])

    def test_detail_pages_of_other_place_are_hidden(self):
        self.assertEqual(self.client.get(
            reverse('staff:loan_reports', args=[self.south.id])).status_code, 404)
        self.assertEqual(self.client.get(
            reverse('staff:view_place_loan', args=[self.south_loan.id])).status_code, 404)
        self.assertEqual(self.client.get(
            reverse('staff:paid_due_history') + f'?id={self.south_loan.id}').status_code, 404)
        self.assertEqual(self.client.get(
            reverse('staff:edit_customer', args=[self.south_loan.customer_id])).status_code, 302)

    def test_staff_adds_place_gets_assigned(self):
        r = self.client.post(reverse('staff:add_place'), {'place_name': 'East'})
        self.assertEqual(r.status_code, 200)
        self.assertTrue(self.staff.places.filter(name='East').exists())

    def test_staff_overdue_is_scoped(self):
        # both loans are 4 dues behind -> overdue
        r = self.client.get(reverse('staff:overdue_loan_data'), **XHR)
        self.assertEqual([d['loan_id'] for d in r.json()['data']], [self.north_loan.id])
        r = self.client.get(reverse('staff:view_overdue_loan') + f'?id={self.north_loan.id}')
        self.assertEqual(r.status_code, 200)

    def test_staff_dashboard_numbers(self):
        r = self.client.get(reverse('staff:dashboard'))
        self.assertEqual(r.context['active_loans'], 1)
        self.assertEqual(r.context['overdue_customers'], 1)
        self.assertEqual(r.context['total_customers'], 1)


class AttendanceTests(BaseFlow):
    def test_checkin_on_time_and_once_per_day(self):
        now = timezone.localtime()
        AttendanceMaster.objects.create(
            start_time=(now + timedelta(hours=1)).time().replace(microsecond=0)
            if now.hour < 22 else time(23, 59),
            end_time=time(23, 59), late_grace_minutes=10, working_days=['Monday'], is_active=True)
        self.staff_login()
        r = self.client.post(reverse('staff:staff_checkin'))
        self.assertEqual(r.status_code, 422)                     # location is required
        r = self.client.post(reverse('staff:staff_checkin'),
                             {'latitude': '8.177800', 'longitude': '77.434400', 'accuracy': '12'})
        self.assertIn(r.status_code, (200, 201), r.content)
        self.assertTrue(StaffCheckIn.objects.filter(staff=self.staff).exists())
        r = self.client.post(reverse('staff:staff_checkin'), {'location_error': 'denied'})
        self.assertEqual(r.status_code, 409)
        r = self.client.get(reverse('staff:attendence'))
        self.assertEqual(r.context['present_days'], 1)

    def test_admin_attendance_pages(self):
        self.client.post(reverse('admin:login_validate'), {'email': 'admin@gmail.com', 'password': 'admin'})
        self.assertEqual(self.client.get(reverse('admin:staff_attendence')).status_code, 200)
        self.assertEqual(self.client.get(reverse('admin:attendance_data'), **XHR).status_code, 200)


class SmokeAllPagesTests(BaseFlow):
    """Every GET page of both panels renders without a server error."""

    def test_admin_pages(self):
        self.admin_login()
        loan, place = self.north_loan, self.north
        urls = [
            reverse('admin:dashboard'), reverse('admin:customer_management'),
            reverse('admin:add_loan'), reverse('admin:loan_registers'), reverse('admin:loan_entries'),
            reverse('admin:loan_reports'), reverse('admin:loan_reports', args=[place.id]),
            reverse('admin:completed_loan'), reverse('admin:place_completed_loan', args=[place.id]),
            reverse('admin:view_place_loan', args=[loan.id]), reverse('admin:overdue_loan'),
            reverse('admin:view_overdue_loan') + f'?id={loan.id}',
            reverse('admin:today_collections'), reverse('admin:collection_list'),
            reverse('admin:edit_loan') + f'?id={loan.id}', reverse('admin:add_staff'),
            reverse('admin:staff_list'), reverse('admin:edit_staff', args=[self.staff.id]),
            reverse('admin:staff_collection_details') + f'?id={self.staff.id}',
            reverse('admin:staff_attendence'), reverse('admin:set_attendance'),
            reverse('admin:loan_request'), reverse('admin:add_lead'), reverse('admin:reports'),
            reverse('admin:paid_due_history') + f'?id={loan.id}',
            reverse('admin:payment_invoice') + f'?id={loan.id}',
            reverse('admin:edit_customer', args=[loan.customer_id]),
            reverse('admin:view_customer_details', args=[loan.id]),
            reverse('admin:reset_password'),
        ]
        for url in urls:
            r = self.client.get(url)
            self.assertEqual(r.status_code, 200, url)

    def test_staff_pages(self):
        self.staff_login()
        loan, place = self.north_loan, self.north
        urls = [
            reverse('staff:dashboard'), reverse('staff:customer_management'), reverse('staff:add_loan'),
            reverse('staff:loan_registers'), reverse('staff:loan_entries'),
            reverse('staff:loan_reports', args=[place.id]), reverse('staff:completed_loan'),
            reverse('staff:place_completed_loan', args=[place.id]),
            reverse('staff:view_place_loan', args=[loan.id]), reverse('staff:overdue_loan'),
            reverse('staff:today_collections'), reverse('staff:collection_list'),
            reverse('staff:attendence'), reverse('staff:edit_loan') + f'?id={loan.id}',
            reverse('staff:paid_due_history') + f'?id={loan.id}',
            reverse('staff:payment_invoice') + f'?id={loan.id}',
            reverse('staff:edit_customer', args=[loan.customer_id]),
            reverse('staff:view_customer_details') + f'?id={loan.id}',
            reverse('staff:reset_password'),
        ]
        for url in urls:
            r = self.client.get(url)
            self.assertEqual(r.status_code, 200, url)

    def test_seed_command(self):
        call_command('seed_demo_data', '--force', stdout=DEVNULL)
        self.assertTrue(Loan.objects.filter(status='completed').exists())
        self.assertGreater(LoanPayment.objects.count(), 100)


# ---------------------------------------------------------------- new features
class SundayScheduleTests(TestCase):
    def test_daily_dues_skip_sundays(self):
        from datetime import date
        from NexusApp.utils.loan_schedule import nth_due_date, working_days_between
        sat = date(2026, 11, 14)                      # Saturday
        self.assertEqual(nth_due_date(sat, 'daily', 1), date(2026, 11, 16))   # Monday, not Sunday
        self.assertEqual(nth_due_date(date(2026, 11, 15), 'daily', 0), date(2026, 11, 16))
        for i in range(40):
            self.assertNotEqual(nth_due_date(sat, 'daily', i).weekday(), 6)
        self.assertEqual(nth_due_date(sat, 'weekly', 1), date(2026, 11, 21))
        self.assertEqual(working_days_between(date(2026, 11, 14), date(2026, 11, 16)), 2)
        self.assertEqual(working_days_between(date(2026, 11, 1), date(2026, 11, 30)), 25)

    def test_sunday_first_due_rejected(self):
        call_command('admin_seeder', stdout=DEVNULL)
        Place.objects.create(name='North')
        self.client.post(reverse('admin:login_validate'), {'email': 'admin@gmail.com', 'password': 'admin'})
        r = self.client.post(reverse('admin:addloan'), dict(LoanFlowTests.loan_post, first_due_date='2026-11-08'))
        self.assertEqual(r.status_code, 400)
        self.assertIn('Sunday', r.json()['errors']['first_due_date'])


class LoanReportFeatureTests(BaseFlow):
    def setUp(self):
        self.admin_login()

    def test_report_row_has_paid_balance_pending_days(self):
        r = self.client.get(reverse('admin:loan_reports_data'), {'place': 'North'}, **XHR)
        row = r.json()['data'][0]
        self.assertEqual(row['paid_amount'], 0)
        self.assertEqual(row['balance_amount'], 10000)
        self.assertGreaterEqual(row['pending_days'], 1)
        self.assertIn('period_report_url', row)

    def test_collection_cards_and_period_report(self):
        today = timezone.localdate()
        LoanPayment.objects.create(loan=self.north_loan, payment_date=today, amount=Decimal('1500'))
        LoanPayment.objects.create(loan=self.south_loan, payment_date=today - timedelta(days=1),
                                   amount=Decimal('700'))
        r = self.client.get(reverse('admin:loan_reports_summary'),
                            {'date': (today - timedelta(days=1)).isoformat()}).json()
        self.assertEqual(r['today_total'], 1500)
        self.assertEqual(r['date_total'], 700)
        r = self.client.get(reverse('admin:loan_reports_summary'), {'place': 'North'}).json()
        self.assertEqual(r['today_total'], 1500)
        r = self.client.get(reverse('admin:loan_period_report') + f'?id={self.north_loan.id}').json()
        self.assertTrue(r['weekly'] and r['monthly'])
        self.assertEqual(sum(w['paid'] for w in r['weekly']), 1500)
        self.assertEqual(r['balance_amount'], 8500)

    def test_staff_summary_is_scoped(self):
        self.client.get(reverse('admin:admin_logout'))
        LoanPayment.objects.create(loan=self.south_loan, payment_date=timezone.localdate(),
                                   amount=Decimal('700'))
        self.staff_login()
        r = self.client.get(reverse('staff:loan_reports_summary')).json()
        self.assertEqual(r['today_total'], 0)
        r = self.client.get(reverse('staff:loan_period_report') + f'?id={self.south_loan.id}')
        self.assertEqual(r.status_code, 404)

    def test_extra_payment_adjusts_and_full_balance_closes(self):
        url = reverse('admin:record_payment')
        base = {'loan_id': self.north_loan.id, 'payment_date': timezone.localdate().isoformat(),
                'payment_method': 'cash', 'payment_status': 'completed'}
        r = self.client.post(url, dict(base, paid_amount='3500'))
        self.assertIn('Extra', r.json()['message'])
        self.assertIn('covers 2 more dues', r.json()['message'])
        r = self.client.post(url, dict(base, paid_amount='7000'))      # more than the balance
        self.assertEqual(r.status_code, 400)
        r = self.client.post(url, dict(base, paid_amount='6500'))      # exactly the balance
        self.assertTrue(r.json()['loan_completed'])
        self.north_loan.refresh_from_db()
        self.assertEqual(self.north_loan.status, 'completed')


class CheckoutTests(BaseFlow):
    def setUp(self):
        AttendanceMaster.objects.create(start_time=time(0, 0), end_time=time(23, 59),
                                        late_grace_minutes=1440, working_days=['Monday'], is_active=True)
        self.staff_login()

    def test_checkout_needs_checkin_and_records_hours_and_location(self):
        loc = {'latitude': '8.1', 'longitude': '77.4', 'accuracy': '20'}
        r = self.client.post(reverse('staff:staff_checkout'), loc)
        self.assertEqual(r.status_code, 409)                       # no check-in yet
        self.client.post(reverse('staff:staff_checkin'), loc)
        c = StaffCheckIn.objects.get(staff=self.staff)
        StaffCheckIn.objects.filter(pk=c.pk).update(
            check_in_time=timezone.now() - timedelta(hours=3, minutes=5, seconds=10))
        r = self.client.post(reverse('staff:staff_checkout'), {'location_error': 'permission denied'})
        self.assertEqual(r.status_code, 200, r.content)
        c.refresh_from_db()
        self.assertEqual(c.working_minutes, 185)
        self.assertEqual(c.working_hours_label, '3h 05m')
        self.assertEqual(str(c.check_in_latitude), '8.100000')
        self.assertIn('permission denied', c.check_out_location_note)
        self.assertEqual(self.client.post(reverse('staff:staff_checkout'), loc).status_code, 409)
        page = self.client.get(reverse('staff:attendence'))
        self.assertContains(page, 'data-attendance-action="checkin"')
        self.assertContains(page, 'data-attendance-action="checkout"')
        self.assertNotContains(self.client.get(reverse('staff:dashboard')), 'data-attendance-action')
        # admin attendance list shows check-out + hours + map link
        self.client.post(reverse('admin:login_validate'), {'email': 'admin@gmail.com', 'password': 'admin'})
        row = [x for x in self.client.get(reverse('admin:attendance_data'), **XHR).json()['data']
               if x['status'] != 'Absent'][0]
        self.assertEqual(row['working_hours'], '3h 05m')
        self.assertIn('google.com/maps', row['check_in_map'])


class PaymentEditApprovalTests(BaseFlow):
    def setUp(self):
        self.payment = LoanPayment.objects.create(
            loan=self.north_loan, payment_date=timezone.localdate(), amount=Decimal('500'),
            collected_by=self.staff)

    def request_edit(self, **kw):
        data = {'payment_id': self.payment.id, 'payment_date': timezone.localdate().isoformat(),
                'amount': '50', 'payment_method': 'cash', 'reason': 'typed 500 instead of 50'}
        data.update(kw)
        return self.client.post(reverse('staff:request_payment_edit'), data)

    def test_edit_waits_for_admin_then_applies(self):
        self.staff_login()
        r = self.request_edit()
        self.assertEqual(r.status_code, 200, r.content)
        self.payment.refresh_from_db()
        self.assertEqual(self.payment.amount, Decimal('500'))     # unchanged until approval
        self.assertEqual(self.request_edit().status_code, 409)   # one pending request at a time
        rows = self.client.get(reverse('staff:paid_due_history_data') + f'?id={self.north_loan.id}',
                               **XHR).json()['data']
        self.assertEqual(rows[0]['edit_status'], 'pending')
        self.assertFalse(rows[0]['can_edit'])

        self.client.cookies.clear()
        self.admin_login()
        data = self.client.get(reverse('admin:payment_edit_requests_data')).json()
        self.assertEqual(data['pending_count'], 1)
        req = data['data'][0]
        r = self.client.post(reverse('admin:review_payment_edit'), {'request_id': req['id'], 'action': 'approve'})
        self.assertEqual(r.status_code, 200, r.content)
        self.payment.refresh_from_db()
        self.assertEqual(self.payment.amount, Decimal('50'))
        r = self.client.post(reverse('admin:review_payment_edit'), {'request_id': req['id'], 'action': 'reject'})
        self.assertEqual(r.status_code, 409)

    def test_reject_and_rules(self):
        self.staff_login()
        self.assertEqual(self.request_edit(amount='999999').status_code, 400)   # above total payable
        self.assertEqual(self.request_edit(reason='x').status_code, 400)
        other = LoanPayment.objects.create(loan=self.north_loan, payment_date=timezone.localdate(),
                                           amount=Decimal('100'), collected_by=None)
        self.assertEqual(self.request_edit(payment_id=other.id).status_code, 403)
        south = LoanPayment.objects.create(loan=self.south_loan, payment_date=timezone.localdate(),
                                           amount=Decimal('100'), collected_by=self.staff)
        self.assertEqual(self.request_edit(payment_id=south.id).status_code, 404)
        self.assertEqual(self.request_edit().status_code, 200)
        self.client.cookies.clear()
        self.admin_login()
        req = self.client.get(reverse('admin:payment_edit_requests_data')).json()['data'][0]
        self.client.post(reverse('admin:review_payment_edit'),
                         {'request_id': req['id'], 'action': 'reject', 'admin_note': 'wrong'})
        self.payment.refresh_from_db()
        self.assertEqual(self.payment.amount, Decimal('500'))
        self.assertEqual(self.client.get(reverse('admin:payment_edit_requests')).status_code, 200)


class TableOrderTests(BaseFlow):
    def test_order_saved_per_user(self):
        import json
        self.admin_login()
        key = '/admin/staff_list/#staffTable'
        r = self.client.post(reverse('admin:table_order'), {'table_key': key, 'keys': json.dumps(['id:3', 'id:1'])})
        self.assertEqual(r.status_code, 200)
        got = self.client.get(reverse('admin:table_order'), {'page': '/admin/staff_list/'}).json()
        self.assertEqual(got['orders'][key], ['id:3', 'id:1'])
        self.client.cookies.clear()
        self.staff_login()
        got = self.client.get(reverse('staff:table_order'), {'page': '/admin/staff_list/'}).json()
        self.assertEqual(got['orders'], {})                       # staff has their own orders
        self.client.post(reverse('staff:table_order'), {'table_key': '/staff/x/#t', 'keys': '["a"]'})
        self.assertEqual(self.client.get(reverse('staff:table_order'), {'page': '/staff/x/'}).json()['orders'],
                         {'/staff/x/#t': ['a']})
        self.client.post(reverse('staff:table_order'), {'table_key': '/staff/x/#t', 'reset': '1'})
        self.assertEqual(self.client.get(reverse('staff:table_order'), {'page': '/staff/x/'}).json()['orders'], {})


class ReportDateFilterExcelTests(BaseFlow):
    """From / To date filters and the Excel (.xlsx) exports of the report pages."""
    XLSX = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'

    def sheet_rows(self, response):
        """Data rows of the downloaded workbook (title, subtitle, blank, header skipped)."""
        from io import BytesIO
        from openpyxl import load_workbook
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response['Content-Type'], self.XLSX)
        self.assertIn('.xlsx', response['Content-Disposition'])
        ws = load_workbook(BytesIO(response.content)).active
        rows = [list(r) for r in ws.iter_rows(min_row=5, values_only=True)]
        return [r for r in rows if r[0] != 'Total']

    def setUp(self):
        self.today = timezone.localdate()
        self.after = (self.today + timedelta(days=1)).isoformat()
        self.long_ago = (self.today - timedelta(days=60)).isoformat()

    def test_loan_reports_date_range_and_excel(self):
        self.admin_login()
        url = reverse('admin:loan_reports_data')
        r = self.client.get(url, {'from_date': self.after}, **XHR).json()
        self.assertEqual(r['data'], [])                       # loans are older than tomorrow
        r = self.client.get(url, {'from_date': self.long_ago, 'to_date': self.today.isoformat()},
                            **XHR).json()
        self.assertEqual(len(r['data']), 2)
        rows = self.sheet_rows(self.client.get(reverse('admin:loan_reports_export')))
        self.assertEqual({r[4] for r in rows}, {'North Cust', 'South Cust'})
        rows = self.sheet_rows(self.client.get(reverse('admin:loan_reports_export'),
                                               {'from_date': self.after}))
        self.assertEqual(rows, [])

    def test_staff_loan_reports_excel_is_scoped(self):
        self.staff_login()
        r = self.client.get(reverse('staff:loan_reports_data'), {'from_date': self.after}, **XHR)
        self.assertEqual(r.json()['data'], [])
        rows = self.sheet_rows(self.client.get(reverse('staff:loan_reports_export')))
        self.assertEqual([r[4] for r in rows], ['North Cust'])

    def test_overdue_date_range_and_excel(self):
        self.admin_login()
        r = self.client.get(reverse('admin:overdue_loan_data'), {'from_date': self.after}, **XHR)
        self.assertEqual(r.json()['data'], [])
        rows = self.sheet_rows(self.client.get(reverse('admin:overdue_loan_export')))
        self.assertEqual(len(rows), 2)
        self.client.cookies.clear()
        self.staff_login()
        rows = self.sheet_rows(self.client.get(reverse('staff:overdue_loan_export')))
        self.assertEqual([r[2] for r in rows], ['North Cust'])

    def test_collections_export_only_inside_range(self):
        old_day = self.today - timedelta(days=3)
        LoanPayment.objects.create(loan=self.north_loan, payment_date=self.today, amount=Decimal('1000'))
        LoanPayment.objects.create(loan=self.south_loan, payment_date=old_day, amount=Decimal('700'))
        self.admin_login()
        # default (no dates) = today only
        rows = self.sheet_rows(self.client.get(reverse('admin:collections_export')))
        self.assertEqual([(r[2], r[8]) for r in rows], [('North Cust', 1000)])
        rows = self.sheet_rows(self.client.get(reverse('admin:collections_export'),
                                               {'from_date': old_day.isoformat(),
                                                'to_date': old_day.isoformat()}))
        self.assertEqual([(r[2], r[8]) for r in rows], [('South Cust', 700)])
        r = self.client.get(reverse('admin:collection_list_data'),
                            {'from_date': old_day.isoformat(), 'to_date': self.today.isoformat()})
        self.assertEqual(len(r.json()['data']), 2)
        r = self.client.get(reverse('admin:today_collections_data'),
                            {'from_date': old_day.isoformat(), 'to_date': self.today.isoformat()})
        self.assertEqual(r.json()['summary']['total'], 1700)

    def test_staff_collections_export_excludes_other_places(self):
        LoanPayment.objects.create(loan=self.north_loan, payment_date=self.today,
                                   amount=Decimal('1000'), collected_by=self.staff)
        # collected by the same staff member, but South is not one of their places
        LoanPayment.objects.create(loan=self.south_loan, payment_date=self.today,
                                   amount=Decimal('700'), collected_by=self.staff)
        self.staff_login()
        rows = self.sheet_rows(self.client.get(reverse('staff:collections_export'),
                                               {'from_date': self.long_ago}))
        self.assertEqual([r[4] for r in rows], ['North'])
        r = self.client.get(reverse('staff:collection_list_data'))
        self.assertEqual([d['place'] for d in r.json()['data']], ['North'])
        r = self.client.get(reverse('staff:today_collections_data'), {'from_date': self.after})
        self.assertEqual(r.json()['data'], [])

    def test_reports_page_range_and_excel(self):
        LoanPayment.objects.create(loan=self.north_loan, payment_date=self.today, amount=Decimal('1000'))
        LoanPayment.objects.create(loan=self.south_loan, payment_date=self.today - timedelta(days=10),
                                   amount=Decimal('700'))
        self.admin_login()
        r = self.client.get(reverse('admin:reports_data'),
                            {'from_date': (self.today - timedelta(days=2)).isoformat()}, **XHR).json()
        self.assertEqual([d['customer'] for d in r['data']], ['North Cust'])
        rows = self.sheet_rows(self.client.get(reverse('admin:reports_export')))
        self.assertEqual(len(rows), 2)
        rows = self.sheet_rows(self.client.get(reverse('admin:reports_export'),
                                               {'to_date': (self.today - timedelta(days=5)).isoformat()}))
        self.assertEqual([r[2] for r in rows], ['South Cust'])

    def test_paid_due_history_range_and_excel(self):
        LoanPayment.objects.create(loan=self.north_loan, payment_date=self.today - timedelta(days=3),
                                   amount=Decimal('1000'))
        LoanPayment.objects.create(loan=self.north_loan, payment_date=self.today, amount=Decimal('500'))
        self.admin_login()
        params = {'id': self.north_loan.id, 'from_date': self.today.isoformat()}
        r = self.client.get(reverse('admin:paid_due_history_data'), params, **XHR).json()
        self.assertEqual([d['paid_due_amount'] for d in r['data']], [500])
        rows = self.sheet_rows(self.client.get(reverse('admin:paid_due_history_export'), params))
        self.assertEqual([r[2] for r in rows], [500])
        self.client.cookies.clear()
        self.staff_login()
        rows = self.sheet_rows(self.client.get(reverse('staff:paid_due_history_export'),
                                               {'id': self.north_loan.id}))
        self.assertEqual(len(rows), 2)

    def test_completed_loans_range_and_excel(self):
        for loan, days in ((self.north_loan, 1), (self.south_loan, 20)):
            loan.status = 'completed'
            loan.closed_date = self.today - timedelta(days=days)
            loan.save()
        self.admin_login()
        recent = {'from_date': (self.today - timedelta(days=5)).isoformat()}
        r = self.client.get(reverse('admin:admin_completed_loan_data'), recent).json()
        self.assertEqual([d['customer_name'] for d in r['data']], ['North Cust'])
        rows = self.sheet_rows(self.client.get(reverse('admin:completed_loan_export')))
        self.assertEqual(len(rows), 2)
        self.client.cookies.clear()
        self.staff_login()
        rows = self.sheet_rows(self.client.get(reverse('staff:completed_loan_export')))
        self.assertEqual([r[1] for r in rows], ['North Cust'])
        r = self.client.get(reverse('staff:completed_loan_data'), {'to_date': self.long_ago}).json()
        self.assertEqual(r['data'], [])

    def test_attendance_range_and_excel(self):
        StaffCheckIn.objects.create(staff=self.staff, check_in_date=self.today,
                                    check_in_time=timezone.now(), status='on_time')
        self.admin_login()
        r = self.client.get(reverse('admin:attendance_data'),
                            {'from_date': self.today.isoformat(), 'to_date': self.today.isoformat()},
                            **XHR).json()
        self.assertIn('Agent One', [d['staff_name'] for d in r['data']])
        rows = self.sheet_rows(self.client.get(reverse('admin:attendance_export'),
                                               {'period': 'range', 'from_date': self.today.isoformat(),
                                                'search': 'EMP900'}))
        self.assertEqual([(r[1], r[7]) for r in rows], [('Agent One', 'Present')])
