import base64
from unittest.mock import patch

import cv2
import numpy as np
from django.test import SimpleTestCase, override_settings

from .services import engine_claude, engine_gemini, engine_grok


class GeminiEngineTests(SimpleTestCase):
    @override_settings(
        GEMINI_API_KEY="test-gemini-key",
        GEMINI_IMAGE_MODEL="gemini-test-image",
        GEMINI_TIMEOUT=240,
    )
    @patch(
        "tryon.services.engine_gemini.garment_on_white",
        return_value=(b"garment", "garment.png", "image/png"),
    )
    @patch("tryon.services.engine_gemini.requests.post")
    def test_sends_both_images_and_decodes_generated_image(self, post, _garment):
        output = np.zeros((2, 2, 3), dtype=np.uint8)
        ok, encoded = cv2.imencode(".png", output)
        self.assertTrue(ok)
        post.return_value.status_code = 200
        post.return_value.json.return_value = {
            "output_image": {"data": base64.b64encode(encoded).decode("ascii")}
        }

        result = engine_gemini.render(np.zeros((2, 2, 3), dtype=np.uint8), object())

        self.assertEqual(result.shape, output.shape)
        self.assertEqual(post.call_args.kwargs["headers"]["x-goog-api-key"], "test-gemini-key")
        payload = post.call_args.kwargs["json"]
        self.assertEqual(payload["model"], "gemini-test-image")
        self.assertEqual([part["type"] for part in payload["input"]], ["text", "image", "image"])
        self.assertEqual(payload["input"][2]["mime_type"], "image/png")

    @override_settings(GEMINI_API_KEY="test-gemini-key")
    @patch(
        "tryon.services.engine_gemini.garment_on_white",
        return_value=(b"garment", "garment.png", "image/png"),
    )
    @patch("tryon.services.engine_gemini.requests.post")
    def test_reports_api_error(self, post, _garment):
        post.return_value.status_code = 403
        post.return_value.reason = "Forbidden"
        post.return_value.json.return_value = {"error": {"message": "API key invalid"}}

        with self.assertRaisesRegex(RuntimeError, "Gemini answered 403: API key invalid"):
            engine_gemini.render(np.zeros((2, 2, 3), dtype=np.uint8), object())


class GrokEngineTests(SimpleTestCase):
    @override_settings(
        XAI_API_KEY="test-xai-key",
        XAI_IMAGE_MODEL="grok-test-image",
        XAI_TIMEOUT=240,
    )
    @patch(
        "tryon.services.engine_grok.garment_on_white",
        return_value=(b"garment", "garment.png", "image/png"),
    )
    @patch("tryon.services.engine_grok.requests.post")
    def test_sends_both_images_and_decodes_generated_image(self, post, _garment):
        output = np.zeros((2, 2, 3), dtype=np.uint8)
        ok, encoded = cv2.imencode(".png", output)
        self.assertTrue(ok)
        post.return_value.status_code = 200
        post.return_value.json.return_value = {
            "data": [{"b64_json": base64.b64encode(encoded).decode("ascii")}]
        }

        result = engine_grok.render(
            np.zeros((2, 2, 3), dtype=np.uint8),
            object(),
            garment_guidance="Navy suit with fine pinstripes.",
        )

        self.assertEqual(result.shape, output.shape)
        self.assertEqual(post.call_args.kwargs["headers"]["Authorization"], "Bearer test-xai-key")
        payload = post.call_args.kwargs["json"]
        self.assertEqual(payload["model"], "grok-test-image")
        self.assertEqual([image["type"] for image in payload["images"]], ["image_url", "image_url"])
        self.assertTrue(payload["images"][0]["url"].startswith("data:image/jpeg;base64,"))
        self.assertTrue(payload["images"][1]["url"].startswith("data:image/png;base64,"))
        self.assertIn("<IMAGE_0>", payload["prompt"])
        self.assertIn("<IMAGE_1>", payload["prompt"])
        self.assertIn("Navy suit with fine pinstripes.", payload["prompt"])
        self.assertEqual(payload["response_format"], "b64_json")

    @override_settings(XAI_API_KEY="test-xai-key")
    @patch(
        "tryon.services.engine_grok.garment_on_white",
        return_value=(b"garment", "garment.png", "image/png"),
    )
    @patch("tryon.services.engine_grok.requests.post")
    def test_reports_xai_validation_error(self, post, _garment):
        post.return_value.status_code = 400
        post.return_value.reason = "Bad Request"
        post.return_value.json.return_value = {
            "error": {"message": "Invalid image reference"}
        }

        with self.assertRaisesRegex(RuntimeError, "xAI answered 400: Invalid image reference"):
            engine_grok.render(np.zeros((2, 2, 3), dtype=np.uint8), object())


class ClaudeEngineTests(SimpleTestCase):
    @override_settings(
        ANTHROPIC_API_KEY="test-anthropic-key",
        CLAUDE_MODEL="claude-test-model",
        CLAUDE_TIMEOUT=120,
    )
    @patch(
        "tryon.services.engine_claude.garment_on_white",
        return_value=(b"garment", "garment.png", "image/png"),
    )
    @patch("tryon.services.engine_claude.requests.post")
    def test_sends_both_images_and_returns_garment_description(self, post, _garment):
        post.return_value.status_code = 200
        post.return_value.json.return_value = {
            "content": [{"type": "text", "text": "Navy suit with fine pinstripes."}]
        }

        result = engine_claude.analyze_garment(np.zeros((2, 2, 3), dtype=np.uint8), object())

        self.assertEqual(result, "Navy suit with fine pinstripes.")
        self.assertEqual(post.call_args.kwargs["headers"]["x-api-key"], "test-anthropic-key")
        payload = post.call_args.kwargs["json"]
        self.assertEqual(payload["model"], "claude-test-model")
        content = payload["messages"][0]["content"]
        image_blocks = [block for block in content if block["type"] == "image"]
        self.assertEqual(len(image_blocks), 2)
        self.assertEqual(image_blocks[1]["source"]["media_type"], "image/png")

    @override_settings(ANTHROPIC_API_KEY="test-anthropic-key")
    @patch(
        "tryon.services.engine_claude.garment_on_white",
        return_value=(b"garment", "garment.png", "image/png"),
    )
    @patch("tryon.services.engine_claude.requests.post")
    def test_reports_anthropic_error(self, post, _garment):
        post.return_value.status_code = 401
        post.return_value.reason = "Unauthorized"
        post.return_value.json.return_value = {
            "error": {"message": "Invalid API key"}
        }

        with self.assertRaisesRegex(RuntimeError, "Anthropic answered 401: Invalid API key"):
            engine_claude.analyze_garment(np.zeros((2, 2, 3), dtype=np.uint8), object())
