import os
import tempfile
import unittest
from datetime import datetime

from app import create_app, db
from app.models import FeedDispenser, FeedingPeriod, PeriodRecipe, Recipe
from config import TestingConfig


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


class LegacyCompatThirdBatchTests(unittest.TestCase):
    def setUp(self) -> None:
        self.app = create_app(LegacyThirdBatchConfig)
        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": "legacy3-admin", "password": "legacy3-secret"}
        )
        self.assertEqual(login.status_code, 200)

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

    def test_feed_dispenser_crud_legacy_endpoints(self) -> None:
        create_resp = self.client.post(
            "/api/feed_dispensers",
            json={"name": "Disp A", "farm": "Farm A", "operator": "Op A", "type": "dispenser"},
        )
        self.assertEqual(create_resp.status_code, 201)
        dispenser_id = create_resp.get_json()["id"]

        get_resp = self.client.get(f"/api/feed_dispensers/{dispenser_id}")
        self.assertEqual(get_resp.status_code, 200)
        self.assertEqual(get_resp.get_json()["name"], "Disp A")

        update_resp = self.client.put(
            f"/api/feed_dispensers/{dispenser_id}",
            json={"name": "Disp A+", "operator": "Op A+"},
        )
        self.assertEqual(update_resp.status_code, 200)

        get_after_update = self.client.get(f"/api/feed_dispensers/{dispenser_id}")
        self.assertEqual(get_after_update.status_code, 200)
        self.assertEqual(get_after_update.get_json()["name"], "Disp A+")

        delete_resp = self.client.delete(f"/api/feed_dispensers/{dispenser_id}")
        self.assertEqual(delete_resp.status_code, 200)

        get_after_delete = self.client.get(f"/api/feed_dispensers/{dispenser_id}")
        self.assertEqual(get_after_delete.status_code, 404)

    def test_period_mutation_and_period_recipe_attach_detach(self) -> None:
        dispenser = FeedDispenser(
            id="d-legacy3", name="Disp B", farm="Farm B", operator="Op B", type="dispenser"
        )
        recipe = Recipe(
            id="r-legacy3", name="Route B", heads_per_trip=20, mixing_time=9, trip_percent=100
        )
        db.session.add_all([dispenser, recipe])
        db.session.commit()

        create_period = self.client.post(
            "/api/feed_dispensers/d-legacy3/periods", json={"name": "Morning"}
        )
        self.assertEqual(create_period.status_code, 201)
        period_id = create_period.get_json()["id"]

        update_period = self.client.put(
            f"/api/feed_dispensers/d-legacy3/periods/{period_id}", json={"name": "Morning+"}
        )
        self.assertEqual(update_period.status_code, 200)

        attach_recipe = self.client.post(
            f"/api/feed_dispensers/d-legacy3/periods/{period_id}/recipes/r-legacy3"
        )
        self.assertEqual(attach_recipe.status_code, 200)

        list_period_recipes = self.client.get(f"/api/periods/{period_id}/recipes")
        self.assertEqual(list_period_recipes.status_code, 200)
        self.assertEqual([r["id"] for r in list_period_recipes.get_json()], ["r-legacy3"])

        detach_recipe = self.client.delete(
            f"/api/feed_dispensers/d-legacy3/periods/{period_id}/recipes/r-legacy3"
        )
        self.assertEqual(detach_recipe.status_code, 200)

        list_after_detach = self.client.get(f"/api/periods/{period_id}/recipes")
        self.assertEqual(list_after_detach.status_code, 200)
        self.assertEqual(list_after_detach.get_json(), [])

        delete_period = self.client.delete(f"/api/feed_dispensers/d-legacy3/periods/{period_id}")
        self.assertEqual(delete_period.status_code, 200)

    def test_delete_recipe_link_keeps_period_alive(self) -> None:
        dispenser = FeedDispenser(
            id="d-legacy3-2", name="Disp C", farm="Farm C", operator="Op C", type="dispenser"
        )
        period = FeedingPeriod(id="p-legacy3-2", name="Evening", dispenser_id=dispenser.id)
        recipe = Recipe(id="r-legacy3-2", name="Route C", heads_per_trip=10, mixing_time=5)
        db.session.add_all([dispenser, period, recipe])
        db.session.flush()
        db.session.add(
            PeriodRecipe(
                period_id=period.id,
                recipe_id=recipe.id,
                order=1,
                created_at=datetime.now(),
                created_by="system",
                updated_by="system",
            )
        )
        db.session.commit()

        resp = self.client.delete(
            "/api/feed_dispensers/d-legacy3-2/periods/p-legacy3-2/recipes/r-legacy3-2"
        )
        self.assertEqual(resp.status_code, 200)

        period_still_exists = FeedingPeriod.query.filter_by(id=period.id, is_deleted=False).first()
        self.assertIsNotNone(period_still_exists)


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