from datetime import timedelta
from decimal import Decimal
from io import StringIO

from django.contrib.auth.models import User
from django.core import mail
from django.core.cache import cache
from django.core.management import call_command
from django.test import TestCase, override_settings
from django.urls import reverse
from django.utils import timezone

from Company.models import company_details
from .models import (
    PlatformInvoice, PlatformPayment, RegistrationRequest, StaffRole,
    StaffRoleAssignment, SubscriptionPackage, SuperAdminProfile, SuperAdminSettings,
    SuperAdminAuditLog,
)

LOCMEM = override_settings(EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend")


def make_admin(email, role_code=None):
    u = User.objects.create_user(username=email, email=email, password="pw-12345-x")
    p = SuperAdminProfile.objects.create(user=u, full_name=email.split("@")[0], email=email)
    if role_code:
        StaffRoleAssignment.objects.create(profile=p, role=StaffRole.objects.get(code=role_code))
    return u, p


def make_company(n=1, **kw):
    d = dict(email=f"c{n}@x.com", contact_no=f"90000000{n:02d}", password="pw",
             Registered_Company_Name=f"Co{n}", status=True, is_verified=True)
    d.update(kw)
    return company_details.objects.create(**d)


REG = {"company_name": "Acme Pvt", "contact_person": "Ann", "email": "ann@acme.com",
       "phone": "9876543210", "employee_count": "25"}


@LOCMEM
class RegistrationFlow(TestCase):
    def setUp(self):
        cache.clear()
        self.user, self.profile = make_admin("boss@x.com")
        self.client.force_login(self.user)

    def submit(self, **over):
        self.client.logout()
        data = dict(REG, **over)
        r = self.client.post(reverse("company_registration_public"), data)
        self.client.force_login(self.user)
        return r

    def test_public_submit_creates_pending(self):
        r = self.submit()
        self.assertEqual(r.status_code, 302)
        reg = RegistrationRequest.objects.get()
        self.assertEqual(reg.status, "PENDING")
        self.assertTrue(reg.events.filter(action="SUBMITTED").exists())

    def test_validation_and_duplicates(self):
        self.assertEqual(self.submit(email="bad").status_code, 400)
        self.assertEqual(self.submit(phone="12").status_code, 400)
        self.submit()
        self.assertEqual(self.submit().status_code, 400)  # pending duplicate
        make_company(5, email="dup@x.com", contact_no="9111111111")
        self.assertEqual(self.submit(email="dup@x.com", phone="9222222222").status_code, 400)

    def test_honeypot_creates_nothing(self):
        self.submit(contact_url="http://spam")
        self.assertEqual(RegistrationRequest.objects.count(), 0)

    def test_registration_can_be_closed(self):
        SuperAdminSettings.objects.create(allow_new_company_registration=False)
        self.client.logout()
        self.assertEqual(self.client.get(reverse("company_registration_public")).status_code, 403)

    def test_approve_creates_company_and_emails(self):
        self.submit()
        reg = RegistrationRequest.objects.get()
        r = self.client.post(reverse("superadmin_registration_action", args=[reg.pk]), {"action": "approve"})
        self.assertEqual(r.status_code, 302)
        reg.refresh_from_db()
        self.assertEqual(reg.status, "APPROVED")
        c = reg.company
        self.assertTrue(c.status and c.is_verified)
        self.assertEqual(c.company_status, "TRIAL")
        self.assertEqual(len(mail.outbox), 1)
        self.assertTrue(SuperAdminAuditLog.objects.filter(
            company=c, action="CREATE_COMPANY", superadmin=self.profile).exists())
        # second approve is a no-op
        self.client.post(reverse("superadmin_registration_action", args=[reg.pk]), {"action": "approve"})
        self.assertEqual(company_details.objects.count(), 1)

    def test_reject_requires_reason(self):
        self.submit()
        reg = RegistrationRequest.objects.get()
        url = reverse("superadmin_registration_action", args=[reg.pk])
        self.client.post(url, {"action": "reject", "reason": ""})
        reg.refresh_from_db(); self.assertEqual(reg.status, "PENDING")
        self.client.post(url, {"action": "reject", "reason": "Documents missing"})
        reg.refresh_from_db(); self.assertEqual(reg.status, "REJECTED")
        self.assertEqual(company_details.objects.count(), 0)


@LOCMEM
class BillingFlow(TestCase):
    def setUp(self):
        self.user, _ = make_admin("boss@x.com")
        self.client.force_login(self.user)
        self.co = make_company(1)
        self.pkg = SubscriptionPackage.objects.create(name="Pro", code="PRO1", plan="PRO",
                                                      monthly_price=1000, yearly_price=10000)

    def create_invoice(self, **over):
        data = {"company": self.co.pk, "package": self.pkg.pk, "billing_cycle": "MONTHLY",
                "due_date": str(timezone.localdate() + timedelta(days=7)), "tax_percent": "18"}
        data.update(over)
        return self.client.post(reverse("superadmin_invoice_create"), data)

    def test_invoice_math_and_payments(self):
        self.create_invoice()
        inv = PlatformInvoice.objects.get()
        self.assertEqual(inv.total_amount, Decimal("1180.00"))
        url = reverse("superadmin_invoice_payment", args=[inv.pk])
        self.client.post(url, {"amount": "500", "method": "UPI"})
        inv.refresh_from_db(); self.assertEqual(inv.status, "PARTIAL")
        self.client.post(url, {"amount": "9999"})  # overpay rejected
        self.assertEqual(inv.payments.count(), 1)
        self.client.post(url, {"amount": "680", "method": "BANK"})
        inv.refresh_from_db(); self.assertEqual(inv.status, "PAID")
        self.assertEqual(inv.balance(), 0)

    def test_cancel_blocked_after_payment(self):
        self.create_invoice()
        inv = PlatformInvoice.objects.get()
        self.client.post(reverse("superadmin_invoice_payment", args=[inv.pk]), {"amount": "10"})
        self.client.post(reverse("superadmin_invoice_status", args=[inv.pk]), {"action": "cancel"})
        inv.refresh_from_db(); self.assertNotEqual(inv.status, "CANCELLED")

    def test_invalid_invoice_rejected(self):
        self.assertEqual(self.create_invoice(amount="-5").status_code, 400)
        self.assertEqual(self.create_invoice(due_date="").status_code, 400)
        self.assertEqual(PlatformInvoice.objects.count(), 0)

    def test_pages_render(self):
        self.create_invoice()
        inv = PlatformInvoice.objects.get()
        for name, args in [("superadmin_billing", []), ("superadmin_payments", []),
                           ("superadmin_invoice_detail", [inv.pk]), ("superadmin_invoice_create", []),
                           ("superadmin_platform_overview", []), ("superadmin_registrations", []),
                           ("superadmin_staff", []), ("superadmin_roles", []),
                           ("superadmin_role_add", []), ("superadmin_staff_add", []),
                           ("superadmin_system_status", [])]:
            r = self.client.get(reverse(name, args=args))
            self.assertEqual(r.status_code, 200, name)
        self.assertEqual(self.client.get(reverse("superadmin_billing") + "?export=csv").status_code, 200)


@LOCMEM
class RolePermissions(TestCase):
    def setUp(self):
        self.co = make_company(1)

    def test_support_role_blocked_from_billing_export_and_staff(self):
        u, _ = make_admin("sup@x.com", "support-agent")
        self.client.force_login(u)
        for name in ("superadmin_billing", "superadmin_staff", "superadmin_employee_export",
                     "superadmin_packages", "superadmin_settings", "superadmin_system_status"):
            r = self.client.get(reverse(name))
            self.assertEqual(r.status_code, 302, name)
            self.assertEqual(r.url, reverse("superadmin_profile"), name)
        self.assertEqual(self.client.get(reverse("superadmin_companies")).status_code, 200)

    def test_post_actions_also_blocked(self):
        u, _ = make_admin("sup@x.com", "support-agent")
        self.client.force_login(u)
        r = self.client.post(reverse("superadmin_company_status", args=[self.co.pk]),
                             {"company_status": "SUSPENDED"})
        self.assertEqual(r.status_code, 302)
        self.co.refresh_from_db(); self.assertEqual(self.co.company_status, "TRIAL")
        r = self.client.post(reverse("superadmin_company_credentials", args=[self.co.pk]))
        self.co.refresh_from_db(); self.assertEqual(self.co.password, "pw")

    def test_inactive_role_locks_user_out(self):
        u, p = make_admin("sup@x.com", "auditor")
        StaffRole.objects.filter(code="auditor").update(is_active=False)
        self.client.force_login(u)
        self.assertEqual(self.client.get(reverse("superadmin_audit_logs")).status_code, 302)

    def test_non_superadmin_user_cannot_enter_portal(self):
        u = User.objects.create_user(username="rand", password="x")
        self.client.force_login(u)
        for name in ("superadmin_platform_overview", "superadmin_billing", "superadmin_companies"):
            self.assertEqual(self.client.get(reverse(name)).status_code, 302, name)
        self.client.logout()
        self.assertEqual(self.client.get(reverse("superadmin_billing")).status_code, 302)

    def test_staff_manager_cannot_escalate(self):
        # custom role: staff.manage + dashboard only
        role = StaffRole.objects.create(name="HR Lead", code="hr-lead",
                                        permissions=["dashboard.view", "staff.manage"])
        u, p = make_admin("lead@x.com")
        StaffRoleAssignment.objects.create(profile=p, role=role)
        self.client.force_login(u)
        billing = StaffRole.objects.get(code="billing-manager")
        r = self.client.post(reverse("superadmin_staff_add"),
                             {"full_name": "N", "email": "n@x.com", "role": billing.pk})
        self.assertEqual(r.status_code, 400)
        self.assertFalse(User.objects.filter(username="n@x.com").exists())
        r = self.client.post(reverse("superadmin_role_add"),
                             {"name": "Evil", "permissions": ["system.backup"]})
        self.assertEqual(r.status_code, 400)

    def test_cannot_remove_last_full_admin(self):
        u, p = make_admin("boss@x.com")
        other_user, other = make_admin("sup@x.com", "support-agent")
        self.client.force_login(u)
        # attempt to demote self blocked; only one full admin exists
        self.client.post(reverse("superadmin_staff_action", args=[p.pk]), {"action": "deactivate"})
        p.refresh_from_db(); self.assertTrue(p.is_active)

    def test_staff_create_and_deactivate(self):
        u, p = make_admin("boss@x.com")
        self.client.force_login(u)
        role = StaffRole.objects.get(code="support-agent")
        r = self.client.post(reverse("superadmin_staff_add"),
                             {"full_name": "New Sup", "email": "new@x.com", "role": role.pk})
        self.assertEqual(r.status_code, 302)
        np = SuperAdminProfile.objects.get(email="new@x.com")
        self.assertEqual(np.staff_role.role, role)
        self.assertEqual(len(mail.outbox), 1)
        self.client.post(reverse("superadmin_staff_action", args=[np.pk]), {"action": "deactivate"})
        np.refresh_from_db(); np.user.refresh_from_db()
        self.assertFalse(np.is_active); self.assertFalse(np.user.is_active)


class ExpiryCommand(TestCase):
    def test_expires_only_overdue(self):
        today = timezone.localdate()
        old = make_company(1, company_status="ACTIVE", subscription_end_date=today - timedelta(days=5))
        ok = make_company(2, company_status="ACTIVE", subscription_end_date=today + timedelta(days=5))
        trial = make_company(3, company_status="TRIAL", trial_end_date=today - timedelta(days=4))
        grace = make_company(4, company_status="ACTIVE", subscription_end_date=today - timedelta(days=2))
        call_command("enforce_subscription_expiry", "--grace-days", "3", stdout=StringIO())
        for c in (old, ok, trial, grace):
            c.refresh_from_db()
        self.assertEqual((old.company_status, old.status), ("EXPIRED", False))
        self.assertEqual(trial.company_status, "EXPIRED")
        self.assertEqual(ok.company_status, "ACTIVE")
        self.assertEqual(grace.company_status, "ACTIVE")

    def test_dry_run_changes_nothing(self):
        c = make_company(1, company_status="ACTIVE",
                         subscription_end_date=timezone.localdate() - timedelta(days=9))
        call_command("enforce_subscription_expiry", "--dry-run", stdout=StringIO())
        c.refresh_from_db(); self.assertEqual(c.company_status, "ACTIVE")
