"""
Integration tests for schedule solver.
Tests end-to-end solver functionality.
"""
import pytest
import json
import subprocess
import sys
from pathlib import Path


SOLVER_PATH = Path(__file__).parent.parent / "schedule_solver.py"


def run_solver(problem_data):
    """Run solver with problem data, return parsed result."""
    result = subprocess.run(
        [sys.executable, str(SOLVER_PATH)],
        input=json.dumps(problem_data),
        capture_output=True,
        text=True
    )

    if result.returncode != 0:
        print("STDERR:", result.stderr, file=sys.stderr)
        raise RuntimeError(f"Solver failed with exit code {result.returncode}")

    return json.loads(result.stdout)


def test_solver_self_test():
    """Test --test flag runs self-test successfully."""
    result = subprocess.run(
        [sys.executable, str(SOLVER_PATH), "--test"],
        capture_output=True,
        text=True
    )

    assert result.returncode == 0, f"Self-test failed: {result.stderr}"
    assert "PASSED" in result.stderr or result.returncode == 0


def test_solver_reads_json_from_stdin(simple_problem):
    """Test solver reads JSON from stdin and writes JSON to stdout."""
    result = run_solver(simple_problem)

    assert isinstance(result, dict)
    assert "status" in result
    assert "assignments" in result
    assert "scorecard" in result


def test_simple_problem_optimal(simple_problem):
    """Test simple problem returns OPTIMAL solution."""
    result = run_solver(simple_problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]
    assert result["scorecard"]["coverageFilled"] >= 3  # At least 3 of 5 shifts filled


def test_locked_shifts_immutable(base_config, base_employee, base_shift):
    """Test locked shifts remain assigned to specified employee."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1},
            {**base_shift, "shiftId": 2, "date": "2026-02-17", "dayOfWeek": 2}
        ],
        "employees": [
            {**base_employee, "userId": 1},
            {**base_employee, "userId": 2, "hourlyRate": 12.0}  # Cheaper employee
        ],
        "lockedShifts": [
            {
                "shiftId": 1,
                "employeeId": 1,  # More expensive employee locked
                "date": "2026-02-16",
                "startTime": "09:00",
                "endTime": "17:00",
                "durationHours": 8.0
            }
        ]
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    # Find locked shift assignment
    locked_assignment = next(
        (a for a in result["assignments"] if a["shiftId"] == 1),
        None
    )

    assert locked_assignment is not None, "Locked shift must be assigned"
    assert locked_assignment["employeeId"] == 1, "Locked shift must stay with employee 1"


def test_role_qualification_enforced(base_config, base_employee, base_shift):
    """Test employees only assigned to shifts they're qualified for."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "minRoleId": 3, "positionName": "Shift Lead"}
        ],
        "employees": [
            {**base_employee, "userId": 1, "role": 4},  # Not qualified (role 4 > 3)
            {**base_employee, "userId": 2, "role": 3}   # Qualified
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    if result["assignments"]:
        assignment = result["assignments"][0]
        assert assignment["employeeId"] == 2, "Only qualified employee should be assigned"


def test_hours_max_never_exceeded(base_config, base_employee, base_shift):
    """Test hoursMax is hard constraint - never exceeded."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": i, "date": f"2026-02-{16+i}", "dayOfWeek": 1+i}
            for i in range(6)  # 6 shifts × 8h = 48h
        ],
        "employees": [
            {**base_employee, "userId": 1, "hoursMax": 40.0, "currentPeriodHours": 0.0}
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    # Calculate total hours for employee
    if result["assignments"]:
        total_hours = sum(8.0 for a in result["assignments"] if a["employeeId"] == 1)
        assert total_hours <= 40.0, f"Employee assigned {total_hours}h > hoursMax 40h"


def test_one_shift_per_day(base_config, base_employee, base_shift):
    """Test employees get at most one shift per day."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "startTime": "09:00", "endTime": "13:00", "durationHours": 4.0},
            {**base_shift, "shiftId": 2, "startTime": "14:00", "endTime": "18:00", "durationHours": 4.0}
        ],
        "employees": [
            {**base_employee, "userId": 1}
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    # Employee should get at most 1 shift (both on same day)
    emp_assignments = [a for a in result["assignments"] if a["employeeId"] == 1]
    assert len(emp_assignments) <= 1, "Employee assigned multiple shifts on same day"


def test_no_overlapping_shifts(base_config, base_employee, base_shift):
    """Test employees don't get overlapping shifts."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "date": "2026-02-16", "startTime": "09:00", "endTime": "13:00", "durationHours": 4.0},
            {**base_shift, "shiftId": 2, "date": "2026-02-16", "startTime": "12:00", "endTime": "16:00", "durationHours": 4.0}
        ],
        "employees": [
            {**base_employee, "userId": 1}
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    # Employee should not be assigned both overlapping shifts
    emp_assignments = [a for a in result["assignments"] if a["employeeId"] == 1]
    assert len(emp_assignments) <= 1, "Employee assigned overlapping shifts"


def test_availability_windows_respected(base_config, base_employee, base_shift):
    """Test employees only assigned during availability windows."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "startTime": "06:00", "endTime": "14:00"}  # Before availability
        ],
        "employees": [
            {
                **base_employee,
                "userId": 1,
                "availability": [
                    {"dayOfWeek": 1, "startTime": "10:00", "endTime": "18:00"}
                ]
            }
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    # Should be infeasible or shift unfilled
    if result["status"] in ["OPTIMAL", "FEASIBLE"]:
        emp_assignments = [a for a in result["assignments"] if a["employeeId"] == 1]
        assert len(emp_assignments) == 0, "Employee assigned outside availability"


def test_time_off_respected(base_config, base_employee, base_shift):
    """Test employees not assigned on time-off days."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "date": "2026-02-16"}
        ],
        "employees": [
            {
                **base_employee,
                "userId": 1,
                "timeOff": [{"date": "2026-02-16", "reason": "Vacation"}]
            }
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    # Should be infeasible or shift unfilled
    if result["status"] in ["OPTIMAL", "FEASIBLE"]:
        emp_assignments = [a for a in result["assignments"] if a["employeeId"] == 1]
        assert len(emp_assignments) == 0, "Employee assigned on time-off day"


def test_max_five_shifts_per_week(base_config, base_employee, base_shift):
    """Test employees get at most 5 shifts per week."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": i, "date": f"2026-02-{16+i}", "dayOfWeek": 1+i, "durationHours": 6.0}
            for i in range(7)  # 7 shifts
        ],
        "employees": [
            {**base_employee, "userId": 1, "shiftsThisWeek": 0, "hoursMax": 50.0}
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    emp_assignments = [a for a in result["assignments"] if a["employeeId"] == 1]
    assert len(emp_assignments) <= 5, f"Employee assigned {len(emp_assignments)} shifts > max 5"


def test_determinism_same_inputs_same_outputs(simple_problem):
    """Test solver is deterministic - same inputs produce same outputs."""
    result1 = run_solver(simple_problem)
    result2 = run_solver(simple_problem)
    result3 = run_solver(simple_problem)

    # All results should be identical
    assert result1["status"] == result2["status"] == result3["status"]
    assert result1["assignments"] == result2["assignments"] == result3["assignments"]
    assert result1["scorecard"]["coverageFilled"] == result2["scorecard"]["coverageFilled"] == result3["scorecard"]["coverageFilled"]


def test_labor_cost_prefers_cheaper_employees(base_config, base_employee, base_shift):
    """Test labor cost priority prefers lower-rate employees."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1}
        ],
        "employees": [
            {**base_employee, "userId": 1, "hourlyRate": 20.0},  # Expensive
            {**base_employee, "userId": 2, "hourlyRate": 12.0}   # Cheap
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    if result["assignments"]:
        # Should prefer cheaper employee
        assignment = result["assignments"][0]
        assert assignment["employeeId"] == 2, "Should prefer cheaper employee"


def test_position_coverage_has_hard_precedence(base_config, base_employee, base_shift):
    """Test position coverage is weighted at 10^7 (hard precedence)."""
    # Coverage should take precedence over labor cost
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1},
            {**base_shift, "shiftId": 2, "date": "2026-02-17", "dayOfWeek": 2}
        ],
        "employees": [
            {**base_employee, "userId": 1, "hourlyRate": 20.0, "hoursMax": 40.0},  # Expensive, high capacity
            {**base_employee, "userId": 2, "hourlyRate": 12.0, "hoursMax": 8.0}    # Cheap, low capacity
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    # Should fill both shifts (coverage) even if it means using expensive employee
    assert result["scorecard"]["coverageFilled"] == 2, "Coverage should be prioritized"


def test_infeasible_returns_status_and_conflicts(base_config, base_shift):
    """Test infeasible problem returns INFEASIBLE with conflict analysis."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "minRoleId": 3, "positionName": "Shift Lead"}
        ],
        "employees": [
            # No employees - model is actually OPTIMAL with 0 assignments (not INFEASIBLE)
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    # With zero employees, model is OPTIMAL (with 0 assignments), not INFEASIBLE
    # Infeasibility occurs when constraints conflict, not when coverage is low
    assert result["status"] in ["OPTIMAL", "FEASIBLE"]
    assert len(result["assignments"]) == 0
    assert len(result["unfilledShifts"]) == 1


def test_timeout_returns_best_feasible(base_config, base_employee, base_shift):
    """Test timeout returns best feasible solution found."""
    # Very short timeout with large problem
    config = {**base_config, "timeout_seconds": 1}

    problem = {
        "config": config,
        "shifts": [
            {**base_shift, "shiftId": i, "date": f"2026-02-{16+(i//3)}", "dayOfWeek": 1+(i//3)}
            for i in range(20)
        ],
        "employees": [
            {**base_employee, "userId": j, "name": f"Emp{j}"}
            for j in range(1, 6)
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    # Should return FEASIBLE or OPTIMAL (not fail)
    assert result["status"] in ["OPTIMAL", "FEASIBLE", "UNKNOWN"]


def test_overnight_shift_handling(base_config, base_employee, base_shift):
    """Test overnight shifts (crossing midnight) are handled correctly."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "startTime": "22:00", "endTime": "06:00", "durationHours": 8.0}
        ],
        "employees": [
            {
                **base_employee,
                "userId": 1,
                "availability": [
                    {"dayOfWeek": 1, "startTime": "20:00", "endTime": "23:59"}
                ]
            }
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    # Should handle overnight shift (may be feasible or not depending on availability handling)
    assert result["status"] in ["OPTIMAL", "FEASIBLE", "INFEASIBLE"]


def test_opening_closing_requires_role_3(base_config, base_employee, base_shift):
    """Test opening/closing shifts (minRoleId <= 3) require Role <= 3."""
    problem = {
        "config": base_config,
        "shifts": [
            {**base_shift, "shiftId": 1, "startTime": "07:00", "endTime": "15:00", "minRoleId": 3}  # Requires role <= 3
        ],
        "employees": [
            {**base_employee, "userId": 1, "role": 4},  # Not qualified for role 3 shifts
            {**base_employee, "userId": 2, "role": 3}   # Qualified
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]

    if result["assignments"]:
        # Should use role 3 employee for shift requiring role <= 3
        assignment = result["assignments"][0]
        assert assignment["employeeId"] == 2, "Shift with minRoleId <= 3 requires role <= 3"


def test_constraint_report_has_binding_and_slack(simple_problem):
    """Test constraint report includes binding and slack constraints."""
    result = run_solver(simple_problem)

    assert "constraintReport" in result
    assert "bindingConstraints" in result["constraintReport"]
    assert "slackConstraints" in result["constraintReport"]


def test_scorecard_has_all_fields(simple_problem):
    """Test scorecard output contains all required fields."""
    result = run_solver(simple_problem)

    scorecard = result["scorecard"]
    assert "totalLaborCost" in scorecard
    assert "fairnessCV" in scorecard
    assert "coverageFilled" in scorecard
    assert "coverageTotal" in scorecard
    assert "constraintViolations" in scorecard
    assert "totalOvertimeHours" in scorecard
    assert "overtimeByEmployee" in scorecard


def test_assignment_factors_for_llm(simple_problem):
    """Test assignment factors include data for LLM analysis."""
    result = run_solver(simple_problem)

    if result["assignments"]:
        assignment = result["assignments"][0]
        factors = assignment["factors"]

        assert "roleQualified" in factors
        assert "availabilityMatch" in factors
        assert "hoursAfter" in factors
        assert "hoursMax" in factors
        assert "hoursDeviation" in factors
        assert "overtimeRisk" in factors
        assert "alternativesCount" in factors
        assert "laborCost" in factors


def test_zero_shifts_problem(base_config, base_employee):
    """Test edge case: zero shifts."""
    problem = {
        "config": base_config,
        "shifts": [],
        "employees": [{**base_employee, "userId": 1}],
        "lockedShifts": []
    }

    result = run_solver(problem)

    assert result["status"] in ["OPTIMAL", "FEASIBLE"]
    assert len(result["assignments"]) == 0
    assert result["scorecard"]["coverageTotal"] == 0


def test_zero_employees_problem(base_config, base_shift):
    """Test edge case: zero employees."""
    problem = {
        "config": base_config,
        "shifts": [{**base_shift, "shiftId": 1}],
        "employees": [],
        "lockedShifts": []
    }

    result = run_solver(problem)

    # Zero employees is OPTIMAL (with 0 assignments), not INFEASIBLE
    assert result["status"] in ["OPTIMAL", "FEASIBLE"]
    assert len(result["assignments"]) == 0
    assert result["scorecard"]["coverageFilled"] == 0


def test_all_employees_at_max_hours(base_config, base_employee, base_shift):
    """Test edge case: all employees at hoursMax."""
    problem = {
        "config": base_config,
        "shifts": [{**base_shift, "shiftId": 1}],
        "employees": [
            {**base_employee, "userId": 1, "currentPeriodHours": 40.0, "hoursMax": 40.0}
        ],
        "lockedShifts": []
    }

    result = run_solver(problem)

    # All at max hours is OPTIMAL (with 0 assignments), not INFEASIBLE
    assert result["status"] in ["OPTIMAL", "FEASIBLE"]
    assert len(result["assignments"]) == 0
    assert result["scorecard"]["coverageFilled"] == 0