"""Tests for core/date_engine.py three-mode logic."""

import os
import sys
import unittest

sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from core.date_engine import (
    days_between,
    detect_date_mode,
    format_date_range,
    offset_date,
    validate_date_order,
)


class TestDetectDateMode(unittest.TestCase):

    def test_mode_a_both_provided_no_ai(self):
        result = detect_date_mode("2025-01-01", "2025-03-01", False, False)
        self.assertEqual(result, "A")

    def test_mode_b_start_only(self):
        result = detect_date_mode("2025-01-01", "", False, False)
        self.assertEqual(result, "B")

    def test_mode_c_end_only(self):
        result = detect_date_mode("", "2025-03-01", False, False)
        self.assertEqual(result, "C")

    def test_raises_value_error_both_blank(self):
        with self.assertRaises(ValueError) as ctx:
            detect_date_mode("", "", False, False)
        self.assertEqual(str(ctx.exception), "At least one date must be provided.")

    def test_raises_value_error_both_ai(self):
        with self.assertRaises(ValueError):
            detect_date_mode("2025-01-01", "2025-03-01", True, True)

    def test_start_ai_true_treats_as_no_start(self):
        # start_ai=True with start provided -> has_start is False -> Mode C if end is real
        result = detect_date_mode("2025-01-01", "2025-03-01", True, False)
        self.assertEqual(result, "C")

    def test_start_ai_true_no_end_raises(self):
        with self.assertRaises(ValueError):
            detect_date_mode("2025-01-01", "", True, False)


class TestValidateDateOrder(unittest.TestCase):

    def test_valid_order_returns_true(self):
        self.assertTrue(validate_date_order("2025-01-01", "2025-06-01"))

    def test_same_date_returns_true(self):
        self.assertTrue(validate_date_order("2025-03-15", "2025-03-15"))

    def test_reversed_order_returns_false(self):
        self.assertFalse(validate_date_order("2025-06-01", "2025-01-01"))

    def test_empty_start_returns_true(self):
        self.assertTrue(validate_date_order("", "2025-06-01"))

    def test_empty_end_returns_true(self):
        self.assertTrue(validate_date_order("2025-01-01", ""))

    def test_both_empty_returns_true(self):
        self.assertTrue(validate_date_order("", ""))


class TestFormatDateRange(unittest.TestCase):

    def test_formats_both_dates_correctly(self):
        result = format_date_range("2025-01-15", "2025-03-20")
        self.assertEqual(result, "Jan 15, 2025 \u2192 Mar 20, 2025")

    def test_handles_none_start(self):
        result = format_date_range(None, "2025-03-20")
        self.assertEqual(result, "Mar 20, 2025")

    def test_handles_empty_start(self):
        result = format_date_range("", "2025-03-20")
        self.assertEqual(result, "Mar 20, 2025")

    def test_handles_none_end(self):
        result = format_date_range("2025-01-15", None)
        self.assertEqual(result, "Jan 15, 2025")

    def test_handles_both_none(self):
        result = format_date_range(None, None)
        self.assertEqual(result, "")

    def test_handles_both_empty(self):
        result = format_date_range("", "")
        self.assertEqual(result, "")


class TestDaysBetween(unittest.TestCase):

    def test_returns_correct_count(self):
        self.assertEqual(days_between("2025-01-01", "2025-01-11"), 10)

    def test_returns_correct_count_reversed(self):
        self.assertEqual(days_between("2025-01-11", "2025-01-01"), 10)

    def test_same_date_returns_zero(self):
        self.assertEqual(days_between("2025-06-01", "2025-06-01"), 0)

    def test_invalid_start_returns_zero(self):
        self.assertEqual(days_between("not-a-date", "2025-01-01"), 0)

    def test_invalid_end_returns_zero(self):
        self.assertEqual(days_between("2025-01-01", ""), 0)


class TestOffsetDate(unittest.TestCase):

    def test_correctly_advances_date(self):
        self.assertEqual(offset_date("2025-01-01", 30), "2025-01-31")

    def test_advance_across_month_boundary(self):
        self.assertEqual(offset_date("2025-01-15", 20), "2025-02-04")

    def test_negative_offset_goes_back(self):
        self.assertEqual(offset_date("2025-03-01", -1), "2025-02-28")

    def test_zero_offset_returns_same(self):
        self.assertEqual(offset_date("2025-06-15", 0), "2025-06-15")

    def test_invalid_base_raises(self):
        with self.assertRaises(ValueError):
            offset_date("not-a-date", 5)


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