"""Expected observations and failure fixtures for the public analysis."""

import csv
import io
import json
import tempfile
import unittest
from pathlib import Path

import analyse


class AnalysisTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.sources, cls.inputs = analyse.load_frozen_sources(analyse.DEFAULT_SOURCE, analyse.BASE)
        cls.rows = analyse.csv_rows(analyse.BASE / "fact-coded.csv")

    def modified(self, assessment_id, **updates):
        return [dict(row, **updates) if row["assessment_id"] == assessment_id else row for row in self.rows]

    def test_all_field_counts(self):
        counts, _, _ = analyse.analyse(self.rows, self.sources, self.inputs)
        columns = ("selected_units", "eligible_denominator", "established", "unknown", "unavailable",
                   "quote_required", "not_applicable", "excluded_source_unavailable", "excluded_not_applicable")
        expected = {
            "source_access": (7, 7, 5, 0, 2, 0, 0, 0, 0),
            "currency": (7, 5, 3, 2, 2, 0, 0, 2, 0),
            "gst_basis": (7, 5, 3, 2, 2, 0, 0, 2, 0),
            "setup_basis": (7, 5, 2, 3, 2, 0, 0, 2, 0),
            "sms_charge_basis": (7, 5, 2, 3, 2, 0, 0, 2, 0),
            "transfer_wait_charge_basis": (7, 5, 0, 5, 2, 0, 0, 2, 0),
            "voice_rounding_increment": (7, 4, 1, 3, 2, 0, 1, 2, 1),
            "voice_minimum_duration": (7, 4, 0, 4, 2, 0, 1, 2, 1),
            "additional_scope_or_base_price": (7, 5, 0, 2, 2, 3, 0, 2, 0),
            "headline_amount": (12, 10, 10, 0, 2, 0, 0, 2, 0),
            "voice_billing_unit": (12, 10, 9, 1, 2, 0, 0, 2, 0),
            "included_voice_allowance": (12, 10, 9, 1, 2, 0, 0, 2, 0),
            "extra_voice_unit_rate": (12, 10, 9, 1, 2, 0, 0, 2, 0),
            "payment_basis": (12, 10, 10, 0, 2, 0, 0, 2, 0),
        }
        self.assertEqual({row["field_id"]: tuple(row[key] for key in columns) for row in counts}, expected)

    def test_inventory_and_critical_lineage(self):
        _, index, summary = analyse.analyse(self.rows, self.sources, self.inputs)
        self.assertEqual(len(index), 12)
        self.assertEqual(summary["selected_providers"], 7)
        self.assertEqual(summary["readable_provider_packages"], 5)
        self.assertEqual(summary["unavailable_provider_packages"], 2)
        self.assertEqual(summary["register_records"], 28)
        self.assertEqual(summary["assessment_rows"], 123)
        self.assertEqual(summary["evidenced_plan_payment_rows"], 10)
        self.assertEqual(summary["unavailable_worksheet_placeholders"], 2)
        self.assertEqual(summary["voice_billing_unit_among_evidenced_rows"], {"CALL": 2, "MINUTE": 7, "UNKNOWN": 1})
        self.assertEqual(summary["payment_basis_among_evidenced_rows"], {"ANNUAL": 1, "MONTHLY": 9})
        facts = {row["assessment_id"]: row for row in self.rows}
        expected = {
            "plan_payment_row:smith-free:headline_amount": ("ESTABLISHED", "0", "S01"),
            "plan_payment_row:smith-pro:extra_voice_unit_rate": ("ESTABLISHED", "2.5", "S02"),
            "plan_payment_row:johnni-annual:headline_amount": ("ESTABLISHED", "44", "J02"),
            "plan_payment_row:johnni-annual:included_voice_allowance": ("UNKNOWN", "", "J01;J02"),
            "provider_source_package:smith:voice_rounding_increment": ("NOT_APPLICABLE", "SELECTED_PLANS_BILL_PER_CALL", "S01;S02"),
            "provider_source_package:ringcentral:voice_rounding_increment": ("ESTABLISHED", "30_SECOND_INCREMENT", "R02"),
            "provider_source_package:ringcentral:voice_minimum_duration": ("UNKNOWN", "", "R02;R04"),
            "provider_source_package:ringcentral:additional_scope_or_base_price": ("QUOTE_REQUIRED", "REQUIRED_RINGEX_BASE_NOT_SELECTED", "R01;R03"),
            "provider_source_package:valory:setup_basis": ("ESTABLISHED", "PUBLISHED_MINIMUM", "V06"),
            "provider_source_package:johnni:setup_basis": ("ESTABLISHED", "NO_STANDARD_SETUP_CHARGE", "J04"),
        }
        for assessment, values in expected.items():
            with self.subTest(assessment=assessment):
                row = facts[assessment]
                self.assertEqual((row["status"], row["coded_value"], row["source_ids"]), values)

    def test_rejects_missing_and_duplicate_assessments(self):
        for rows, message in ((self.rows[1:], "Missing or unexpected assessment"),
                              (self.rows + self.rows[:1], "Duplicate or missing assessment_id")):
            with self.subTest(message=message):
                with self.assertRaisesRegex(ValueError, message):
                    analyse.analyse(rows, self.sources, self.inputs)

    def test_rejects_wrong_source_lineage(self):
        fixtures = (
            ("provider_source_package:valory:setup_basis", "J04", "wrong-provider source link"),
            ("plan_payment_row:valory-core:headline_amount", "V02", "outside the worksheet plan"),
            ("plan_payment_row:johnni-annual:headline_amount", "J06", "No accepted evidence"),
        )
        for assessment, link, message in fixtures:
            with self.subTest(assessment=assessment):
                with self.assertRaisesRegex(ValueError, message):
                    analyse.analyse(self.modified(assessment, source_ids=link), self.sources, self.inputs)

    def test_rejects_misclassified_rows_and_model_only_values(self):
        fixtures = (
            ("plan_payment_row:botbloke-quote:payment_basis", "ESTABLISHED", "MONTHLY", "Wrong eligibility or code"),
            ("provider_source_package:smith:voice_rounding_increment", "UNKNOWN", "", "Wrong time exclusion basis"),
            ("provider_source_package:valory:voice_minimum_duration", "ESTABLISHED", "0", "No accepted evidence"),
            ("plan_payment_row:smith-pro:extra_voice_unit_rate", "ESTABLISHED", "2", "Value disagrees with worksheet"),
        )
        for assessment, status, value, message in fixtures:
            with self.subTest(assessment=assessment):
                with self.assertRaisesRegex(ValueError, message):
                    analyse.analyse(self.modified(assessment, status=status, coded_value=value), self.sources, self.inputs)

    def test_rejects_changed_frozen_input(self):
        with tempfile.TemporaryDirectory() as temp:
            source_dir = Path(temp)
            for file in analyse.SOURCE_FILES:
                (source_dir / file).write_bytes((analyse.DEFAULT_SOURCE / file).read_bytes())
            path = source_dir / "pricing-source-register.csv"
            path.write_bytes(path.read_bytes() + b"\n")
            with self.assertRaisesRegex(ValueError, "Frozen input changed: pricing-source-register.csv"):
                analyse.load_frozen_sources(source_dir, analyse.BASE)

    def test_generated_outputs_and_integrity_manifest(self):
        artifacts = analyse.generate(analyse.BASE, analyse.DEFAULT_SOURCE)
        self.assertEqual(set(artifacts), {"counts.csv", "plan-row-index.csv", "summary.json", "method.sha256", "manifest.json"})
        table = list(csv.DictReader(io.StringIO(artifacts["plan-row-index.csv"].decode("utf-8"))))
        self.assertEqual({row["provider_id"] for row in table if row["row_type"] == "UNAVAILABLE_PLACEHOLDER"},
                         {"botbloke", "transfertoai"})
        manifest = json.loads(artifacts["manifest.json"])
        self.assertEqual(set(manifest["files"]), (set(artifacts) - {"manifest.json"}) | set(analyse.PACKAGE_INPUTS))
        for name, expected in manifest["files"].items():
            contents = artifacts[name] if name in artifacts else (analyse.BASE / name).read_bytes()
            self.assertEqual(analyse.sha256(contents), expected)


if __name__ == "__main__":
    unittest.main()
