import os
import tempfile
import unittest
from datetime import datetime

from app import create_app, db
from app.models import (
    ComponentStock,
    FeedDispenser,
    LoadingReport,
    UnloadingReport,
)
from config import TestingConfig


class RouteResponseContractsConfig(TestingConfig):
    _TMP_DIR = tempfile.mkdtemp(prefix="wesp-route-contracts-tests-")
    SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.join(_TMP_DIR, 'recipes_test.db')}"
    SQLALCHEMY_BINDS = {"reports": f"sqlite:///{os.path.join(_TMP_DIR, 'reports_test.db')}"}
    AUTH_LOGIN = "contract-admin"
    AUTH_PASSWORD = "contract-secret"


class RouteResponseContractsTests(unittest.TestCase):
    def setUp(self) -> None:
        self.app = create_app(RouteResponseContractsConfig)
        self.client = self.app.test_client()
        self.ctx = self.app.app_context()
        self.ctx.push()
        db.create_all()
        self._login()

    def tearDown(self) -> None:
        db.session.remove()
        db.drop_all()
        self.ctx.pop()

    def _login(self) -> None:
        resp = self.client.post(
            "/api/auth/login",
            json={"login": "contract-admin", "password": "contract-secret"},
        )
        self.assertEqual(resp.status_code, 200)

    def test_reports_loading_contract_fields(self) -> None:
        db.session.add(
            LoadingReport(
                id="lr-1",
                recipe_id="r-1",
                recipe_name="Recipe 1",
                start_time=datetime.now(),
                total_weight=321.5,
                version=7,
            )
        )
        db.session.commit()

        resp = self.client.get("/api/reports/loading?limit=10&offset=0")
        self.assertEqual(resp.status_code, 200)
        body = resp.get_json()
        self.assertIsInstance(body, list)
        self.assertEqual(len(body), 1)
        row = body[0]
        self.assertIn("id", row)
        self.assertIn("recipe_id", row)
        self.assertIn("recipe_name", row)
        self.assertIn("start_time", row)
        self.assertIn("end_time", row)
        self.assertIn("total_weight", row)
        self.assertIn("version", row)

    def test_reports_unloading_contract_fields(self) -> None:
        db.session.add(
            UnloadingReport(
                id="ur-1",
                recipe_id="r-2",
                recipe_name="Recipe 2",
                loading_report_id="lr-1",
                start_time=datetime.now(),
                total_weight=200.0,
                total_unloaded_weight=150.0,
                remaining_weight=50.0,
                version=3,
            )
        )
        db.session.commit()

        resp = self.client.get("/api/reports/unloading?limit=10&offset=0")
        self.assertEqual(resp.status_code, 200)
        body = resp.get_json()
        self.assertIsInstance(body, list)
        self.assertEqual(len(body), 1)
        row = body[0]
        self.assertIn("id", row)
        self.assertIn("recipe_id", row)
        self.assertIn("recipe_name", row)
        self.assertIn("start_time", row)
        self.assertIn("end_time", row)
        self.assertIn("total_weight", row)
        self.assertIn("total_unloaded_weight", row)
        self.assertIn("remaining_weight", row)
        self.assertIn("version", row)

    def test_equipment_contract_fields(self) -> None:
        db.session.add(
            FeedDispenser(
                id="fd-1",
                name="Dispenser 1",
                farm="Farm A",
                operator="Operator A",
                type="dispenser",
                is_active=True,
                version=2,
            )
        )
        db.session.commit()

        resp = self.client.get("/api/feed_dispensers?limit=10&offset=0")
        self.assertEqual(resp.status_code, 200)
        body = resp.get_json()
        self.assertIsInstance(body, list)
        self.assertEqual(len(body), 1)
        row = body[0]
        self.assertIn("id", row)
        self.assertIn("name", row)
        self.assertIn("farm", row)
        self.assertIn("operator", row)
        self.assertIn("type", row)
        self.assertIn("is_active", row)
        self.assertIn("version", row)

    def test_sklad_contract_fields(self) -> None:
        db.session.add(
            ComponentStock(
                id="stock-1",
                component_id="cmp-1",
                component_name="Corn",
                total_kg=1000.0,
                inflow_kg=100.0,
                baseline_consumed_kg=50.0,
                stocktake_at=datetime.now(),
                updated_at=datetime.now(),
                updated_by="tester",
                sort_order=1,
            )
        )
        db.session.commit()

        resp = self.client.get("/api/sklad/components?limit=10&offset=0")
        self.assertEqual(resp.status_code, 200)
        body = resp.get_json()
        self.assertIsInstance(body, list)
        self.assertEqual(len(body), 1)
        row = body[0]
        self.assertIn("id", row)
        self.assertIn("component_id", row)
        self.assertIn("component_name", row)
        self.assertIn("total_kg", row)
        self.assertIn("inflow_kg", row)
        self.assertIn("baseline_consumed_kg", row)
        self.assertIn("stocktake_at", row)
        self.assertIn("updated_at", row)
        self.assertIn("updated_by", row)


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