import copy
import json
from pathlib import Path
import unittest
from analyze_reviews import analyze


class EvaluationTests(unittest.TestCase):
    def setUp(self):
        self.data = json.loads(Path(__file__).with_name('example-ledger.json').read_text())

    def test_duplicate_findings_are_not_additive_across_reviewers(self):
        result = analyze(self.data)
        self.assertEqual(result['unique_implemented_issues_across_groups'], 4)
        self.assertEqual(result['groups']['Tool A']['code_addressed_comments'], 3)
        self.assertEqual(result['groups']['Tool A']['unique_implemented_issues'], 2)
        self.assertEqual(result['groups']['Tool B']['unique_implemented_issues'], 3)

    def test_replies_are_not_implemented_code(self):
        a = analyze(self.data)['groups']['Tool A']
        self.assertEqual(a['addressed_comments'], 4)
        self.assertEqual(a['reply_addressed_comments'], 1)
        self.assertEqual(a['unique_implemented_issues'], 2)

    def test_self_open_and_outside_period_are_excluded(self):
        result = analyze(self.data)
        self.assertEqual(result['included_merged_prs'], 1)
        self.assertEqual(result['excluded_review_records'], 3)
        self.assertNotIn('Author', result['groups'])

    def test_unknown_resolution_retained_and_issue_cost_suppressed(self):
        a = analyze(self.data)['groups']['Tool A']
        self.assertEqual(a['suggestions'], 6)
        self.assertEqual(a['unknown_comments'], 1)
        self.assertAlmostEqual(a['assessed_resolution_coverage'], 5/6, places=6)
        self.assertIsNone(a['cost_per_unique_implemented_issue'])

    def test_invoice_and_estimate_do_not_double_count(self):
        a = analyze(self.data)['groups']['Tool A']
        self.assertEqual(a['recorded_cost'], 120)
        self.data['costs'][1]['selected'] = True
        with self.assertRaisesRegex(ValueError, 'cost pool'):
            analyze(self.data)

    def test_mixed_use_cost_stays_visible_without_unit_cost(self):
        self.data['costs'][2]['scope'] = 'mixed_use'
        b = analyze(self.data)['groups']['Tool B']
        self.assertEqual(b['recorded_cost'], 180)
        self.assertIsNone(b['cost_per_estimated_expert_review_hour'])
        self.assertIsNone(b['cost_per_unique_implemented_issue'])

    def test_missing_output_and_unmatched_scope_suppress_ratios(self):
        self.data['reviews'][1]['estimated_expert_review_hours'] = None
        b = analyze(self.data)['groups']['Tool B']
        self.assertIsNone(b['cost_per_estimated_expert_review_hour'])
        self.data['costs'][2]['matched_to_review_scope'] = False
        b = analyze(self.data)['groups']['Tool B']
        self.assertIsNone(b['cost_per_unique_implemented_issue'])

    def test_post_merge_evidence_does_not_receive_pre_merge_credit(self):
        self.data['comments'][0]['evidence_at'] = '2026-10-11T00:00:00Z'
        with self.assertRaisesRegex(ValueError, 'precede merge'):
            analyze(self.data)

    def test_nonfinite_cost_and_mixed_currency_are_rejected(self):
        self.data['costs'][0]['amount'] = float('nan')
        with self.assertRaisesRegex(ValueError, 'finite'):
            analyze(self.data)
        self.data['costs'][0]['amount'] = 120
        self.data['costs'][0]['currency'] = 'EUR'
        with self.assertRaisesRegex(ValueError, 'currency'):
            analyze(self.data)

    def test_missing_identity_does_not_invent_unique_issue(self):
        self.data['comments'][6]['issue_id'] = None
        b = analyze(self.data)['groups']['Tool B']
        self.assertEqual(b['unique_implemented_issues'], 2)
        self.assertIsNone(b['cost_per_unique_implemented_issue'])

    def test_cost_output_values_are_supplied_estimates(self):
        result = analyze(self.data)
        self.assertEqual(result['groups']['Tool A']['cost_per_estimated_expert_review_hour'], 100)
        self.assertEqual(result['groups']['Tool B']['cost_per_estimated_expert_review_hour'], 75)
        self.assertIsNone(result['groups']['Human reviewers']['cost_per_estimated_expert_review_hour'])

    def test_empty_population_has_no_division_or_invented_values(self):
        self.data.update(pull_requests=[],reviews=[],comments=[],costs=[])
        result = analyze(self.data)
        self.assertEqual(result['groups'], {})
        self.assertEqual(result['unique_implemented_issues_across_groups'], 0)

    def test_distinct_row_ids_cannot_duplicate_a_review_assessment(self):
        duplicate = copy.deepcopy(self.data['reviews'][0])
        duplicate['id'] = 'another-row-for-the-same-reviewer'
        self.data['reviews'].append(duplicate)
        with self.assertRaisesRegex(ValueError, 'PR/reviewer'):
            analyze(self.data)

    def test_ambiguous_flags_fail_instead_of_silently_changing_the_cohort(self):
        for field in ('synthetic', 'excluded', 'matched_to_review_scope'):
            data = copy.deepcopy(self.data)
            if field == 'synthetic':
                data[field] = 'false'
            elif field == 'excluded':
                data['pull_requests'][0][field] = 'false'
            else:
                data['costs'][0][field] = 'true'
            with self.subTest(field=field), self.assertRaisesRegex(ValueError, 'boolean'):
                analyze(data)

    def test_individually_finite_values_cannot_overflow_group_totals(self):
        self.data['reviews'][0]['estimated_expert_review_hours'] = 1e308
        second = copy.deepcopy(self.data['reviews'][0])
        second.update(id='huge2', reviewer_id='botA-2')
        self.data['reviews'].append(second)
        with self.assertRaisesRegex(ValueError, 'Aggregate.*finite'):
            analyze(self.data)


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