"""Monthly Chit Fund flow tests (admin full control, staff view + collect)."""
from datetime import date
from decimal import Decimal

from django.urls import reverse
from django.utils import timezone

from NexusApp.models import ChitGroup, ChitMember, ChitPayment, ChitTerm
from NexusApp.tests import BaseFlow  # also applies the Python 3.14 test-client shim
from NexusApp.utils.chit_service import auction_split, month_start


class ChitFundTests(BaseFlow):
    def create_chit(self, **kw):
        data = {'name': 'Gold 1 Lakh', 'chit_value': '100000', 'total_members': '4', 'total_months': '4',
                'monthly_amount': '25000', 'start_month': month_start(timezone.localdate()).strftime('%Y-%m'),
                'due_day': '5', 'commission_percent': '5', 'auction_type': 'auction',
                'place': str(self.north.id), 'status': 'active'}
        data.update(kw)
        return self.client.post(reverse('admin:chit_save'), data)

    def add_members(self, chit, n):
        for i in range(n):
            r = self.client.post(reverse('admin:chit_member_save'),
                                 {'chit_id': chit.id, 'name': f'Member {i + 1}', 'phone': f'90000000{i:02d}'})
            self.assertEqual(r.status_code, 200, r.content)

    def test_admin_full_flow(self):
        self.admin_login()
        r = self.create_chit()
        self.assertEqual(r.status_code, 200, r.content)
        chit = ChitGroup.objects.get(name='Gold 1 Lakh')
        self.assertEqual(chit.terms.count(), 4)
        self.assertTrue(all(t.due_date.weekday() != 6 for t in chit.terms.all()))
        self.add_members(chit, 4)
        r = self.client.post(reverse('admin:chit_member_save'), {'chit_id': chit.id, 'name': 'Extra', 'phone': '9000000099'})
        self.assertEqual(r.status_code, 400)                      # chit is full

        # month 2 has a different due + prize (admin sets each month)
        t1, t2 = chit.terms.order_by('term_no')[:2]
        m1, m2 = list(chit.members.all())[:2]
        r = self.client.post(reverse('admin:chit_term_save'), {
            'term_id': t2.id, 'due_amount': '24000', 'prize_amount': '90000', 'bid_discount': '10000',
            'commission_amount': '5000', 'dividend_per_member': '1250', 'winner_id': m2.id})
        self.assertEqual(r.status_code, 200, r.content)
        t2.refresh_from_db()
        self.assertEqual(t2.due_amount, Decimal('24000'))
        # winner of month 1; m2 already won month 2 so cannot win month 1
        r = self.client.post(reverse('admin:chit_term_save'), {
            'term_id': t1.id, 'due_amount': '25000', 'prize_amount': '100000', 'winner_id': m2.id})
        self.assertEqual(r.status_code, 400)
        r = self.client.post(reverse('admin:chit_term_save'), {
            'term_id': t1.id, 'due_amount': '25000', 'prize_amount': '100000', 'winner_id': m1.id,
            'claimed': '1'})
        self.assertEqual(r.status_code, 200, r.content)

        # payments: partial, then rest, then over-pay refused
        pay = {'term_id': t1.id, 'member_id': m1.id, 'paid_date': timezone.localdate().isoformat(), 'method': 'cash'}
        self.assertEqual(self.client.post(reverse('admin:chit_pay'), dict(pay, amount='10000')).status_code, 200)
        self.assertEqual(self.client.post(reverse('admin:chit_pay'), dict(pay, amount='20000')).status_code, 400)
        self.assertEqual(self.client.post(reverse('admin:chit_pay'), dict(pay, amount='15000')).status_code, 200)
        self.assertEqual(self.client.post(reverse('admin:chit_pay'), dict(pay, amount='1')).status_code, 400)

        d = self.client.get(reverse('admin:chit_detail_data'), {'id': chit.id, 'term': 1}).json()
        st = {m['name']: m for m in d['members']}
        self.assertEqual(st['Member 1']['term_status'], 'Paid')
        self.assertTrue(st['Member 1']['claimed'])
        self.assertTrue(st['Member 1']['prize_received'])
        self.assertFalse(st['Member 3']['claimed'])
        self.assertNotEqual(st['Member 3']['term_status'], 'Paid')
        self.assertEqual(d['selected_term']['collected'], 25000)
        self.assertEqual(d['selected_term']['paid_members'], 1)
        self.assertEqual(d['claimed_count'], 2)

        # list cards + reports + excel
        lst = self.client.get(reverse('admin:chit_list_data')).json()
        self.assertEqual(lst['cards']['active'], 1)
        self.assertEqual(lst['cards']['collected'], 25000)
        rep = self.client.get(reverse('admin:chit_reports_data'), {'chit': chit.id}).json()
        self.assertEqual(rep['totals']['collected'], 25000)
        r = self.client.get(reverse('admin:chit_reports_export'))
        self.assertEqual(r['Content-Type'], 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
        self.assertEqual(self.client.get(reverse('admin:chit_list_export'))['Content-Type'],
                         'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
        for url in [reverse('admin:chit_list'), reverse('admin:chit_view', args=[chit.id]),
                    reverse('admin:chit_reports')]:
            self.assertEqual(self.client.get(url).status_code, 200, url)

        # cannot delete with payments; can delete member without payments
        self.assertEqual(self.client.post(reverse('admin:chit_delete'), {'id': chit.id}).status_code, 400)
        m4 = chit.members.get(name='Member 4')
        self.assertEqual(self.client.post(reverse('admin:chit_member_delete'), {'id': m4.id}).status_code, 200)

    def test_months_and_amounts_validation(self):
        self.admin_login()
        r = self.create_chit(total_members='0', chit_value='abc')
        self.assertEqual(r.status_code, 400)
        self.create_chit()
        chit = ChitGroup.objects.get()
        # shrink months: extra terms removed; grow: added
        r = self.create_chit(id=chit.id, total_months='6')
        self.assertEqual(chit.terms.count(), 6)
        r = self.create_chit(id=chit.id, total_months='3')
        self.assertEqual(chit.terms.count(), 3)
        prize, commission, dividend, due = auction_split(chit, Decimal('15000'))
        self.assertEqual(prize, Decimal('85000'))
        self.assertEqual(commission, Decimal('5000'))
        self.assertEqual(dividend, Decimal('2500'))       # (15000-5000)/4
        self.assertEqual(due, Decimal('22500'))

    def test_staff_sees_only_their_place_and_can_collect(self):
        north = ChitGroup.objects.create(name='North Chit', chit_value=1000, total_members=2, total_months=2,
                                         monthly_amount=500, start_month=date(2026, 1, 1), place=self.north)
        south = ChitGroup.objects.create(name='South Chit', chit_value=1000, total_members=2, total_months=2,
                                         monthly_amount=500, start_month=date(2026, 1, 1), place=self.south)
        from NexusApp.utils.chit_service import sync_terms
        sync_terms(north), sync_terms(south)
        m = ChitMember.objects.create(chit=north, ticket_no=1, name='A', phone='9000000001')
        sm = ChitMember.objects.create(chit=south, ticket_no=1, name='B', phone='9000000002')
        self.staff_login()
        names = [r['name'] for r in self.client.get(reverse('staff:chit_list_data')).json()['data']]
        self.assertEqual(names, ['North Chit'])
        self.assertEqual(self.client.get(reverse('staff:chit_view', args=[south.id])).status_code, 404)
        self.assertEqual(self.client.get(reverse('staff:chit_view', args=[north.id])).status_code, 200)
        term = north.terms.get(term_no=1)
        r = self.client.post(reverse('staff:chit_pay'), {'term_id': term.id, 'member_id': m.id, 'amount': '500'})
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(ChitPayment.objects.get().collected_by, self.staff)
        sterm = south.terms.get(term_no=1)
        r = self.client.post(reverse('staff:chit_pay'), {'term_id': sterm.id, 'member_id': sm.id, 'amount': '500'})
        self.assertEqual(r.status_code, 404)
        # staff cannot reach admin-only actions
        r = self.client.post(reverse('admin:chit_term_save'), {'term_id': term.id})
        self.assertIn(r.status_code, (302, 401))
        self.assertEqual(self.client.get(reverse('staff:chit_reports')).status_code, 200)
        self.assertEqual(ChitTerm.objects.filter(chit=north).count(), 2)

    def test_seed_demo_chits(self):
        from django.core.management import call_command
        from NexusApp.tests import DEVNULL
        call_command('seed_demo_chits', stdout=DEVNULL)
        self.assertEqual(ChitGroup.objects.count(), 4)
        self.assertTrue(ChitPayment.objects.exists())
        call_command('seed_demo_chits', '--remove', stdout=DEVNULL)
        self.assertEqual(ChitGroup.objects.count(), 0)


class ChitFormPageTests(BaseFlow):
    def test_create_with_member_rows_and_month_amounts(self):
        import json
        self.admin_login()
        self.assertEqual(self.client.get(reverse('admin:chit_new')).status_code, 200)
        members = [{'name': 'Ravi', 'phone': '9000000001', 'address': 'A', 'aadhaar_number': ''},
                   {'name': 'Sita', 'phone': '9000000002', 'address': '', 'aadhaar_number': '123412341234'},
                   {'name': '', 'phone': '', 'address': '', 'aadhaar_number': ''}]      # blank row skipped
        terms = [{'term_no': 1, 'due_amount': '5000', 'prize_amount': '15000'},
                 {'term_no': 2, 'due_amount': '4500', 'prize_amount': '14000'},
                 {'term_no': 3, 'due_amount': '4000', 'prize_amount': '13000'}]
        data = {'name': 'Row Chit', 'chit_value': '15000', 'total_members': '3', 'total_months': '3',
                'monthly_amount': '5000', 'start_month': '2026-11', 'due_day': '5', 'commission_percent': '5',
                'members_json': json.dumps(members), 'terms_json': json.dumps(terms)}
        r = self.client.post(reverse('admin:chit_save'), data)
        self.assertEqual(r.status_code, 200, r.content)
        chit = ChitGroup.objects.get(name='Row Chit')
        self.assertEqual(list(chit.members.values_list('ticket_no', 'name')), [(1, 'Ravi'), (2, 'Sita')])
        self.assertEqual([t.due_amount for t in chit.terms.all()], [Decimal('5000'), Decimal('4500'), Decimal('4000')])
        self.assertEqual([t.prize_amount for t in chit.terms.all()], [Decimal('15000'), Decimal('14000'), Decimal('13000')])

        # bad phone in a member row is refused
        bad = dict(data, members_json=json.dumps([{'name': 'X', 'phone': '12'}]))
        self.assertEqual(self.client.post(reverse('admin:chit_save'), bad).status_code, 400)

        # edit: rename Ravi, drop Sita, add Gopi; change month 2 due
        ravi, sita = chit.members.all()
        self.assertEqual(self.client.get(reverse('admin:chit_edit', args=[chit.id])).status_code, 200)
        members2 = [{'id': ravi.id, 'name': 'Ravi K', 'phone': '9000000001'},
                    {'name': 'Gopi', 'phone': '9000000003'}]
        terms[1]['due_amount'] = '4200'
        r = self.client.post(reverse('admin:chit_save'), dict(data, id=chit.id, members_json=json.dumps(members2),
                                                            terms_json=json.dumps(terms)))
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(list(chit.members.values_list('ticket_no', 'name')), [(1, 'Ravi K'), (2, 'Gopi')])
        self.assertEqual(chit.terms.get(term_no=2).due_amount, Decimal('4200'))

        # a member with a payment cannot be dropped
        ChitPayment.objects.create(term=chit.terms.get(term_no=1), member=chit.members.get(name='Gopi'),
                                   amount=Decimal('100'), paid_date=date(2026, 11, 5))
        r = self.client.post(reverse('admin:chit_save'), dict(data, id=chit.id, members_json=json.dumps(members2[:1]),
                                                            terms_json=json.dumps(terms)))
        self.assertEqual(r.status_code, 400)
        self.assertEqual(chit.members.count(), 2)
