from copy import deepcopy
from io import BytesIO

import openpyxl
import pytest
from fastapi.testclient import TestClient

from src.backend.main import app
from src.backend.routers.audits.export import ROUTE
from src.backend.users.manage import verify_auth0

ROUTE = f"/api{ROUTE}"

# Dependency override to mock the Auth0 verifier, so that tests can run without
# needing to authenticate with Auth0.
app.dependency_overrides[verify_auth0] = lambda: {"mock_auth0": "credentials"}


class TestExportRowsToXlsx:
    payload = {
        "sheets": [
            {
                "columns": [
                    ["key1", "label1"],
                    ["key2", "label2"],
                ],
                "rows": [
                    {"key1": "value1", "key2": "value2"},
                ],
                "name": "Sheet A",
            },
            {
                "columns": [
                    ["key3", "label3"],
                    ["key4", "label4"],
                ],
                "rows": [
                    {"key3": "value3", "key4": "value4"},
                ],
                "name": "Sheet B",
            },
        ],
    }

    @pytest.fixture(scope="class")
    def response_bytes(self) -> BytesIO:
        with TestClient(app) as client:
            response = client.post(f"{ROUTE}/xlsx", json=self.payload)
        assert response.status_code == 200
        return BytesIO(response.content)

    @pytest.fixture(scope="class")
    def response_as_workbook(self, response_bytes):
        return openpyxl.load_workbook(response_bytes)

    def test_response_sheet_names(self, response_as_workbook):
        expected_sheet_names = [sheet["name"] for sheet in self.payload["sheets"]]
        assert response_as_workbook.sheetnames == expected_sheet_names

    def test_response_sheet_rows(self, response_as_workbook):
        for idx, sheet in enumerate(response_as_workbook):
            sheet_payload = self.payload["sheets"][idx]
            columns = sheet_payload["columns"]
            sheet_col_keys = [col[0] for col in columns]
            sheet_col_labels = [col[1] for col in columns]

            sheet_first_row = sheet[1]
            assert [cell.value for cell in sheet_first_row] == sheet_col_labels

            for row in sheet.iter_rows(min_row=2):
                row_idx = row[0].row - 2
                row_payload = sheet_payload["rows"][row_idx]
                expected_row_values = [row_payload[key] for key in sheet_col_keys]
                assert [cell.value for cell in row] == expected_row_values

    def test_no_sheet_names_provided(self):
        """Test that defaults are used and an exception is not raised."""
        payload = deepcopy(self.payload)
        for sheet in payload["sheets"]:
            sheet.pop("name")
        with TestClient(app) as client:
            response = client.post(f"{ROUTE}/xlsx", json=self.payload)
        assert response.status_code == 200


@pytest.mark.skip(reason="Not implemented yet. This endpoint is unfinished.")
class TestAuditReport:
    def test_audit_report(self):
        payload = {
            "audit_group_id": 0,
            "label_name": "mock_label",
            "artist_image": "https://samples-files.com/samples/Images/jpg/480-360-sample.jpg",
            "as_pdf": False,
        }
        with TestClient(app) as client:
            response = client.post(f"{ROUTE}/audit_report", json=payload)
        assert response.status_code == 200