import os
import tempfile
import unittest
from datetime import datetime

from app import create_app, db
from app.models import (
    ComponentLoadingTime,
    FeedDispenser,
    LoadingReport,
    LoadingReportComponent,
    SyncClient,
    SyncDelivery,
    SyncQueue,
    UnloadingReport,
    UnloadingReportGroup,
)
from config import TestingConfig


class LegacyFirstBatchConfig(TestingConfig):
    _TMP_DIR = tempfile.mkdtemp(prefix="wesp-legacy-batch1-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 = "legacy-admin"
    AUTH_PASSWORD = "legacy-secret"


class LegacyCompatFirstBatchTests(unittest.TestCase):
    def setUp(self) -> None:
        self.app = create_app(LegacyFirstBatchConfig)
        self.client = self.app.test_client()
        self.ctx = self.app.app_context()
        self.ctx.push()
        db.create_all()
        login = self.client.post(
            "/api/auth/login", json={"login": "legacy-admin", "password": "legacy-secret"}
        )
        self.assertEqual(login.status_code, 200)

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

    def test_sync_clients_endpoints(self) -> None:
        now = datetime.now()
        c = SyncClient(node_id="node-1", client_name="Client 1", status="active", last_seen=now)
        db.session.add(c)
        db.session.flush()
        task = SyncQueue(
            id="task-1",
            table_name="recipe",
            record_id="r-1",
            action="update",
            status="processing",
            created_at=now,
            processed_at=now,
        )
        db.session.add(task)
        db.session.flush()
        db.session.add(SyncDelivery(client_id=c.id, task_id=task.id, delivered_at=now))
        db.session.commit()

        clients = self.client.get("/api/sync/clients")
        self.assertEqual(clients.status_code, 200)
        clients_data = clients.get_json()
        self.assertIsInstance(clients_data, list)
        self.assertEqual(clients_data[0]["node_id"], "node-1")

        set_name = self.client.put(
            "/api/sync/clients/node-1/display_name", json={"display_name": "Truck-1"}
        )
        self.assertEqual(set_name.status_code, 200)
        self.assertEqual(set_name.get_json().get("display_name"), "Truck-1")

        deliveries = self.client.get("/api/sync/clients/node-1/deliveries?hours=24")
        self.assertEqual(deliveries.status_code, 200)
        self.assertIsInstance(deliveries.get_json().get("deliveries"), list)
        self.assertEqual(deliveries.get_json()["deliveries"][0]["task_id"], "task-1")

        delete = self.client.delete("/api/sync/clients/node-1")
        self.assertEqual(delete.status_code, 200)
        self.assertTrue(delete.get_json().get("success"))

    def test_feed_dispenser_names_endpoint(self) -> None:
        db.session.add_all(
            [
                FeedDispenser(id="fd-1", name="A", farm="F", operator="O"),
                FeedDispenser(id="fd-2", name="B", farm="F", operator="O"),
            ]
        )
        db.session.commit()

        resp = self.client.get("/api/feed_dispensers/names")
        self.assertEqual(resp.status_code, 200)
        body = resp.get_json()
        self.assertEqual(body, ["A", "B"])

    def test_legacy_reports_endpoint_payload_shape(self) -> None:
        now = datetime.now()
        loading = LoadingReport(
            id="lr-1",
            recipe_id="recipe-1",
            recipe_name="Recipe 1",
            start_time=now,
            total_weight=123.4,
            target_mixing_time=120,
            actual_mixing_time=130,
            dispenser_type="dispenser",
        )
        db.session.add(loading)
        db.session.flush()
        db.session.add(
            LoadingReportComponent(
                id="lrc-1",
                report_id=loading.id,
                component_name="Corn",
                target_weight=50,
                actual_weight=55,
                overload=5,
                loading_order=1,
            )
        )
        db.session.add(
            ComponentLoadingTime(
                id="clt-1",
                report_id=loading.id,
                component_name="Corn",
                start_time=now,
                end_time=now,
                loading_duration=3.2,
                loading_order=1,
            )
        )
        unloading = UnloadingReport(
            id="ur-1",
            recipe_id="recipe-1",
            recipe_name="Recipe 1",
            loading_report_id=loading.id,
            start_time=now,
            total_weight=100,
            total_unloaded_weight=80,
            remaining_weight=20,
        )
        db.session.add(unloading)
        db.session.flush()
        db.session.add(
            UnloadingReportGroup(
                id="urg-1",
                report_id=unloading.id,
                name="Group 1",
                target_weight=50,
                unloaded_weight=40,
                remaining_weight=10,
                distribution_type="percent",
                distribution_value=50,
                order=1,
            )
        )
        db.session.commit()

        resp = self.client.get("/api/reports")
        self.assertEqual(resp.status_code, 200)
        body = resp.get_json()
        self.assertIsInstance(body, list)
        self.assertEqual(len(body), 1)
        row = body[0]
        self.assertIn("components", row)
        self.assertIn("component_loading_times", row)
        self.assertIn("unloading_data", row)
        self.assertIsInstance(row["components"], list)
        self.assertIsInstance(row["component_loading_times"], list)


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