# Tests for the additive employee bulk export / import API.
#   python manage.py test Employee.tests_bulk_io
import io

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase
from openpyxl import Workbook, load_workbook

from Employee.models import (
    BankAccount, CandidateEducation, CandidateExperience, CandidateCompensation,
    EmployeeAccount, EmployeeDT,
)
from Recruitment.common import candidates_qs
from Recruitment.tests_hiring_plus import client, mk_company, mk_emp, mk_role

B = "/api/employee-data/"


def up(name, data):
    return SimpleUploadedFile(name, data, content_type="application/octet-stream")


def csv_bytes(*lines):
    return ("\n".join(lines) + "\n").encode()


def xlsx_bytes(sheets):
    wb = Workbook()
    wb.remove(wb.active)
    for title, rows in sheets.items():
        ws = wb.create_sheet(title)
        for r in rows:
            ws.append(r)
    b = io.BytesIO()
    wb.save(b)
    return b.getvalue()


class BulkBase(TestCase):
    def setUp(self):
        self.co = mk_company()
        self.admin = client(self.co)
        self.r_hr = mk_role(self.co, "hr_exec", can_view_employees=True, can_create_employees=True,
                            can_edit_employees=True)
        self.r_view = mk_role(self.co, "viewer", can_view_employees=True)
        self.r_none = mk_role(self.co, "nobody", can_view_employees=False)
        self.r_super = mk_role(self.co, "hr_super", can_manage_employees=True)
        self.hr = client(mk_emp(self.co, "Hr One", self.r_hr))
        self.viewer = client(mk_emp(self.co, "View Only", self.r_view))
        self.nobody = client(mk_emp(self.co, "No Body", self.r_none))

    def imp(self, who, name, data, **form):
        return who.post(B + "import/", {"file": up(name, data), **form}, format="multipart")


class Permissions(BulkBase):
    def test_roles(self):
        for path in ("export/", "template/"):
            self.assertEqual(self.admin.get(B + path).status_code, 200)
            self.assertEqual(self.hr.get(B + path).status_code, 200)
            self.assertEqual(self.viewer.get(B + path).status_code, 200)
            self.assertEqual(self.nobody.get(B + path).status_code, 403)
        csv = csv_bytes("Name,Email", "A B,ab@x.com")
        self.assertEqual(self.imp(self.viewer, "e.csv", csv).status_code, 403)
        self.assertEqual(self.imp(self.nobody, "e.csv", csv).status_code, 403)
        self.assertEqual(self.imp(self.hr, "e.csv", csv).status_code, 200)
        self.assertEqual(self.client.post(B + "import/").status_code, 401)

    def test_create_only_hr_cannot_update(self):
        r_create = mk_role(self.co, "creator", can_view_employees=True, can_create_employees=True)
        c = client(mk_emp(self.co, "Creator", r_create))
        csv = csv_bytes("Name,Email", "A B,ab2@x.com")
        self.assertEqual(self.imp(c, "e.csv", csv).status_code, 403)                  # upsert needs edit
        self.assertEqual(self.imp(c, "e.csv", csv, mode="create").status_code, 200)

    def test_cannot_hand_out_write_role(self):
        csv = csv_bytes("Name,Email,Role Code", "Sneaky,sn@x.com,hr_super")
        r = self.imp(self.hr, "e.csv", csv).json()["data"]
        self.assertEqual(r["failed_rows"], 1)
        self.assertIn("only the company Admin", r["errors"][0]["error"])
        self.assertFalse(EmployeeDT.objects.filter(email="sn@x.com").exists())
        r = self.imp(self.admin, "e.csv", csv).json()["data"]
        self.assertEqual(r["failed_rows"], 0)
        self.assertEqual(EmployeeAccount.objects.get(employee__email="sn@x.com").role.role_code, "hr_super")


class ImportCsv(BulkBase):
    def test_create_is_employee_not_candidate(self):
        csv = csv_bytes(
            "Name,Email,Phone,DOB,Joining Date,Department,Work Shift,Basic Salary,Password",
            "Asha Rao,asha@x.com,9876543210,21/05/1994,01-04-2022,Sales,day shift,\"25,000\",Pass@123",
            "No Pass,nopass@x.com,,,,,,,",
        )
        r = self.imp(self.admin, "e.csv", csv)
        self.assertEqual(r.status_code, 200, r.content)
        d = r.json()["data"]
        self.assertEqual((d["saved_rows"], d["failed_rows"]), (2, 0))
        e = EmployeeDT.objects.get(email="asha@x.com")
        self.assertEqual(str(e.Date_of_Birth), "1994-05-21")
        self.assertEqual(str(e.Date_of_Joining), "2022-04-01")
        self.assertEqual(e.Work_sift, "Day Shift")
        self.assertEqual(str(e.Basic_Salary), "25000.00")
        self.assertEqual(e.candidate_status, "JOINED")
        self.assertEqual(e.Employee_Status, "Activate")
        self.assertFalse(e.applied_position)
        self.assertFalse(candidates_qs(self.co).filter(pk=e.pk).exists())
        self.assertTrue(e.account.is_login_enabled)
        self.assertEqual(e.password, "Pass@123")
        self.assertFalse(EmployeeDT.objects.get(email="nopass@x.com").account.is_login_enabled)

    def test_bad_rows_reported_good_rows_saved(self):
        csv = csv_bytes(
            "Name,Email,Date of Birth",
            "Good One,good@x.com,1990-01-01",
            "Bad Date,bad@x.com,31/31/2020",
            "No Email,,1990-01-01",
            "Bad Mail,notanemail,1990-01-01",
        )
        d = self.imp(self.admin, "e.csv", csv).json()["data"]
        self.assertEqual((d["saved_rows"], d["failed_rows"]), (1, 3))
        self.assertEqual([e["row"] for e in d["errors"]], [3, 4, 5])
        self.assertTrue(EmployeeDT.objects.filter(email="good@x.com").exists())

    def test_dry_run_saves_nothing(self):
        csv = csv_bytes("Name,Email", "Dry Run,dry@x.com")
        d = self.imp(self.admin, "e.csv", csv, dry_run="true").json()["data"]
        self.assertTrue(d["dry_run"])
        self.assertEqual(d["saved_rows"], 1)
        self.assertFalse(EmployeeDT.objects.filter(email="dry@x.com").exists())

    def test_update_keeps_data_on_blank_and_matches_code_or_email(self):
        e = mk_emp(self.co, "Old Name", Designation="Exec", Department="Ops")
        csv = csv_bytes("Employee Code,Name,Designation,Department", f"{e.employee_code},New Name,,Sales")
        d = self.imp(self.admin, "e.csv", csv).json()["data"]
        self.assertEqual(d["sheets"]["Employees"]["updated"], 1)
        e.refresh_from_db()
        self.assertEqual((e.name, e.Designation, e.Department), ("New Name", "Exec", "Sales"))
        csv = csv_bytes("Email,Designation", f"{e.email.upper()},Lead")
        self.imp(self.admin, "e.csv", csv)
        e.refresh_from_db()
        self.assertEqual(e.Designation, "Lead")
        self.assertEqual(EmployeeDT.objects.filter(company=self.co, email__iexact=e.email).count(), 1)

    def test_modes(self):
        e = mk_emp(self.co, "Existing")
        csv = csv_bytes("Name,Email", f"Existing,{e.email}", "Brand New,bn@x.com")
        d = self.imp(self.admin, "e.csv", csv, mode="create").json()["data"]
        self.assertEqual((d["sheets"]["Employees"]["created"], d["sheets"]["Employees"]["failed"]), (1, 1))
        d = self.imp(self.admin, "e.csv", csv_bytes("Name,Email", "Ghost,ghost@x.com"), mode="update").json()["data"]
        self.assertEqual(d["failed_rows"], 1)
        self.assertEqual(self.imp(self.admin, "e.csv", csv, mode="zzz").status_code, 400)

    def test_other_company_isolation(self):
        other = mk_company("b")
        foreign = mk_emp(other, "Foreign")
        d = self.imp(self.admin, "e.csv", csv_bytes("Name,Email", f"X,{foreign.email}")).json()["data"]
        self.assertIn("another company", d["errors"][0]["error"])
        d = self.imp(self.admin, "e.csv", csv_bytes("Employee Code,Name,Email", f"{foreign.employee_code},X,x1@x.com")).json()["data"]
        self.assertIn("another company", d["errors"][0]["error"])
        foreign.refresh_from_db()
        self.assertEqual(foreign.name, "Foreign")

    def test_file_validation(self):
        self.assertEqual(self.admin.post(B + "import/", {}, format="multipart").status_code, 400)
        self.assertEqual(self.imp(self.admin, "e.pdf", b"x").status_code, 400)
        self.assertEqual(self.imp(self.admin, "e.csv", b"").status_code, 400)
        self.assertEqual(self.imp(self.admin, "e.xlsx", b"not a zip").status_code, 400)
        self.assertEqual(self.imp(self.admin, "e.csv", csv_bytes("Name,Email")).status_code, 400)

    def test_unknown_columns_ignored_and_reported(self):
        d = self.imp(self.admin, "e.csv", csv_bytes("Name,Email,Favourite Colour", "A,a1@x.com,blue")).json()["data"]
        self.assertEqual(d["ignored_columns"], ["Favourite Colour"])
        self.assertEqual(d["saved_rows"], 1)


class ImportExcelAndRoundTrip(BulkBase):
    def test_multisheet_xlsx(self):
        data = xlsx_bytes({
            "Employees": [["Name", "Email", "Current Annual CTC", "Bank Name", "Account Number", "IFSC Code", "Account Type"],
                          ["Neha Jain", "neha@x.com", 480000, "HDFC", "123456789", "HDFC0001", "savings"]],
            "Education": [["Email", "Degree Course", "Passing Year"], ["neha@x.com", "B.Com", 2015]],
            "Experience": [["Email", "Company Name", "Start Date", "Previous CTC"], ["neha@x.com", "ABC", "2017-06-01", 300000]],
            "Bank Accounts": [["Email", "Bank Name", "Account Number", "IFSC Code"], ["neha@x.com", "SBI", "999", "SBIN0001"]],
        })
        d = self.imp(self.admin, "e.xlsx", data).json()["data"]
        self.assertEqual(d["failed_rows"], 0, d["errors"])
        e = EmployeeDT.objects.get(email="neha@x.com")
        self.assertEqual(CandidateCompensation.objects.get(employee=e).current_annual_ctc, 480000)
        self.assertEqual(CandidateEducation.objects.filter(employee=e).count(), 1)
        self.assertEqual(CandidateExperience.objects.get(employee=e).company_name, "ABC")
        self.assertEqual(BankAccount.objects.filter(employee=e).count(), 2)
        # importing again must not duplicate children
        self.imp(self.admin, "e.xlsx", data)
        self.assertEqual(CandidateEducation.objects.filter(employee=e).count(), 1)
        self.assertEqual(CandidateExperience.objects.filter(employee=e).count(), 1)
        self.assertEqual(BankAccount.objects.filter(employee=e).count(), 2)

    def test_child_row_without_employee_fails_cleanly(self):
        data = xlsx_bytes({"Education": [["Email", "Degree Course"], ["ghost@x.com", "BA"]]})
        d = self.imp(self.admin, "e.xlsx", data).json()
        self.assertEqual(d["data"]["failed_rows"], 1)
        self.assertEqual(self.imp(self.admin, "e.xlsx", data).status_code, 400)

    def test_template_then_export_then_reimport(self):
        t = self.admin.get(B + "template/?file=xlsx")
        wb = load_workbook(io.BytesIO(t.content))
        self.assertEqual(wb.sheetnames, ["Instructions", "Employees", "Education", "Experience", "Bank Accounts"])
        # the untouched template itself imports cleanly
        d = self.imp(self.admin, "t.xlsx", t.content, dry_run="true").json()["data"]
        self.assertEqual(d["failed_rows"], 0, d["errors"])

        csv = csv_bytes("Name,Email,Phone Number,Password,Aadhaar Number",
                        "Plus Phone,pp@x.com,+91 98765 43210,Secret@1,123456789012")
        self.imp(self.admin, "e.csv", csv)
        x = self.admin.get(B + "export/?file=xlsx")
        self.assertEqual(x.status_code, 200)
        self.assertNotIn(b"Secret@1", x.content)
        wb = load_workbook(io.BytesIO(x.content))
        self.assertEqual(wb.sheetnames, ["Employees", "Education", "Experience", "Bank Accounts"])
        self.assertNotIn("Password", [c.value for c in wb["Employees"][1]])
        d = self.imp(self.admin, "x.xlsx", x.content).json()["data"]
        self.assertEqual(d["failed_rows"], 0, d["errors"])
        self.assertEqual(EmployeeDT.objects.get(email="pp@x.com").phone_number, "+91 98765 43210")
        self.assertEqual(EmployeeDT.objects.get(email="pp@x.com").password, "Secret@1")   # untouched by blank cell

    def test_export_csv_filters_and_candidates_excluded(self):
        mk_emp(self.co, "Sales Guy", Department="Sales")
        mk_emp(self.co, "Ops Guy", Department="Ops", is_active=False) if False else None
        cand = EmployeeDT.objects.create(company=self.co, name="Cand Idate", email="cand@x.com",
                                         Employee_Status="Candidate", applied_position="Dev")
        body = self.admin.get(B + "export/").content.decode("utf-8-sig")
        self.assertIn("Sales Guy", body)
        self.assertNotIn("Cand Idate", body)
        body = self.admin.get(B + "export/?include_candidates=true").content.decode("utf-8-sig")
        self.assertIn("Cand Idate", body)
        body = self.admin.get(B + "export/?department=sales").content.decode("utf-8-sig")
        self.assertIn("Sales Guy", body)
        self.assertNotIn("Hr One", body)
        self.assertEqual(self.admin.get(B + "export/?sheet=zzz").status_code, 400)
        # another company never leaks
        other = mk_company("b")
        mk_emp(other, "Secret Other")
        self.assertNotIn("Secret Other", self.admin.get(B + "export/?file=csv").content.decode("utf-8-sig"))
