import os
import tempfile
import unittest

from app import create_app, db
from config import TestingConfig

from tests.kiosk_test_env import kiosk_client_kwargs


class AdditionalRoutesConfig(TestingConfig):
    _TMP_DIR = tempfile.mkdtemp(prefix="wesp-additional-routes-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 = "extra-admin"
    AUTH_PASSWORD = "extra-secret"
    KIOSK_ENFORCE_PAIRED_ONLY = True


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

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

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

    def test_scales_current_weight_requires_auth(self) -> None:
        kw = kiosk_client_kwargs()
        unauthorized = self.client.get("/current_weight", **kw)
        self.assertEqual(unauthorized.status_code, 401)

        # Pair terminal (kiosk flow) and verify access.
        self._login(**kw)
        self.client.get("/scales", **kw)
        pair = self.client.post("/api/kiosk/pair-token", **kw)
        self.assertEqual(pair.status_code, 200)
        token = pair.get_json().get("token")
        self.assertTrue(token)
        self.client.get(f"/api/kiosk/pair/confirm?token={token}", **kw)
        self.client.post(
            "/api/kiosk/pair/confirm",
            data={"token": token},
            content_type="application/x-www-form-urlencoded",
            **kw,
        )
        authorized = self.client.get("/current_weight", **kw)
        self.assertEqual(authorized.status_code, 200)
        self.assertIn("weight", authorized.get_json())

    def test_reports_loading_supports_pagination_and_validation(self) -> None:
        self._login()
        invalid = self.client.get("/api/reports/loading?limit=bad")
        self.assertEqual(invalid.status_code, 400)
        self.assertTrue(invalid.get_json().get("error"))

        ok = self.client.get("/api/reports/loading?limit=10&offset=0")
        self.assertEqual(ok.status_code, 200)
        self.assertIsInstance(ok.get_json(), list)

    def test_equipment_and_sklad_support_pagination_and_validation(self) -> None:
        self._login()

        invalid_equipment = self.client.get("/api/feed_dispensers?offset=nope")
        self.assertEqual(invalid_equipment.status_code, 400)
        self.assertTrue(invalid_equipment.get_json().get("error"))

        ok_equipment = self.client.get("/api/feed_dispensers?limit=5&offset=0")
        self.assertEqual(ok_equipment.status_code, 200)
        self.assertIsInstance(ok_equipment.get_json(), list)

        invalid_sklad = self.client.get("/api/sklad/components?limit=abc")
        self.assertEqual(invalid_sklad.status_code, 400)
        self.assertTrue(invalid_sklad.get_json().get("error"))

        ok_sklad = self.client.get("/api/sklad/components?limit=5&offset=0")
        self.assertEqual(ok_sklad.status_code, 200)
        self.assertIsInstance(ok_sklad.get_json(), list)


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