import io
import json
import tempfile
import unittest
import zipfile
from pathlib import Path
from unittest import mock
from xml.etree import ElementTree

import server


class FakeOpenAIResponse:
    def __init__(self, model):
        self.model = model

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc, traceback):
        return False

    def read(self):
        return ('{"id":"' + self.model + '","object":"model"}').encode("utf-8")


class FakeOpenAIContentResponse(FakeOpenAIResponse):
    def read(self):
        sections = [
            {
                "heading": f"Bagian Unik {index}",
                "body": (
                    f"Pembahasan unik bagian {index} untuk GAN89 dan domain pengujian ini "
                    "menjelaskan kebutuhan pembaca Indonesia secara natural, terarah, dan "
                    "informatif. Setiap paragraf memakai sudut berbeda agar struktur konten "
                    "tidak terasa seperti salinan template atau pengulangan halaman lain."
                ),
            }
            for index in range(1, 6)
        ]
        content = {
            "seo_title": "GAN89 Panduan Unik untuk Domain Pengujian",
            "meta_description": "Panduan GAN89 dengan informasi unik, terarah, dan mudah dipahami pembaca Indonesia.",
            "keywords": ["GAN89", "GAN89 Login", "GAN89 Daftar", "panduan unik", "domain pengujian"],
            "hero_heading": "Temukan Panduan GAN89 yang Lebih Terarah",
            "hero_subheading": "Informasi baru yang disusun khusus untuk kebutuhan pembaca domain pengujian.",
            "cta_label": "Buka GAN89",
            "article_sections": sections,
            "faqs": [
                {"question": f"Pertanyaan unik {index}?", "answer": f"Jawaban lengkap untuk FAQ nomor {index}."}
                for index in range(1, 6)
            ],
            "reviews": [
                {
                    "name": f"Pengguna {index}",
                    "city": ["Jakarta", "Bandung", "Surabaya", "Medan", "Makassar"][index - 1],
                    "rating": 5,
                    "body": f"Review persona Indonesia nomor {index} dengan pengalaman membaca yang jelas.",
                }
                for index in range(1, 6)
            ],
        }
        result = {
            "id": "resp_test_adminseo",
            "status": "completed",
            "output": [{
                "type": "message",
                "content": [{"type": "output_text", "text": json.dumps(content)}],
            }],
            "usage": {"input_tokens": 100, "output_tokens": 500},
        }
        return json.dumps(result).encode("utf-8")


class UserIsolationTests(unittest.TestCase):
    def test_projects_media_groups_and_output_paths_are_scoped_per_user(self):
        with tempfile.TemporaryDirectory() as temp_dir:
            root = Path(temp_dir)
            with (
                mock.patch.object(server, "DATA_DIR", root / "data"),
                mock.patch.object(server, "DB_PATH", root / "data" / "adminseo.sqlite3"),
                mock.patch.object(server, "GENERATED_DIR", root / "generated"),
                mock.patch.object(server, "UPLOAD_DIR", root / "uploads"),
            ):
                server.init_db()
                server.clear_login_failures("203.0.113.10")
                for _ in range(server.LOGIN_MAX_FAILURES):
                    server.record_login_failure("203.0.113.10")
                self.assertTrue(server.login_is_rate_limited("203.0.113.10"))
                server.clear_login_failures("203.0.113.10")
                self.assertFalse(server.login_is_rate_limited("203.0.113.10"))
                with server.db() as connection:
                    admin_id = int(connection.execute(
                        "SELECT id FROM users WHERE username = ?", (server.DEFAULT_USERNAME,)
                    ).fetchone()["id"])
                    admin2_id = int(connection.execute(
                        "SELECT id FROM users WHERE username = ?", (server.SECONDARY_USERNAME,)
                    ).fetchone()["id"])

                created = server.create_user_account("Operator.01", "password-kuat")
                self.assertEqual("operator.01", created["username"])
                self.assertIsNotNone(server.authenticate("operator.01", "password-kuat"))
                server.change_user_password(
                    created["id"],
                    "password-kuat",
                    "password-baru-yang-kuat",
                    "password-baru-yang-kuat",
                )
                self.assertIsNone(server.authenticate("operator.01", "password-kuat"))
                self.assertIsNotNone(server.authenticate("operator.01", "password-baru-yang-kuat"))
                self.assertEqual([], server.list_projects(created["id"]))
                with self.assertRaisesRegex(ValueError, "Username sudah digunakan"):
                    server.create_user_account("OPERATOR.01", "password-lain")
                self.assertNotIn("/pembuatan-admin", server.index_html("domains", "admin"))
                self.assertIn('/account/security', server.index_html("domains", "admin"))
                self.assertIn('action="/account/security"', server.account_security_html("admin"))
                ai_markup = server.index_html("ai-analytics", "admin")
                self.assertIn("AI MENU", ai_markup)
                self.assertIn('data-cms-page="ai-analytics"', ai_markup)
                self.assertIn('aria-expanded="true" aria-controls="aiMenuSubmenu"', ai_markup)
                api_markup = server.index_html("ai-api", "admin")
                self.assertIn('value="gpt-5.6-terra"', api_markup)
                self.assertIn('value="gpt-5.6-sol"', api_markup)
                self.assertIn('value="gpt-5.4-mini"', api_markup)
                self.assertIn('value="gpt-4.1"', api_markup)
                self.assertIn('value="__custom__"', api_markup)
                self.assertEqual(
                    "gpt-5.6-terra",
                    server.public_ai_connection(admin_id)["model"],
                )
                flow_markup = server.index_html("ai-schema", "admin")
                self.assertIn('id="seoFlowInput"', flow_markup)
                self.assertIn('id="seoFlowSvg"', flow_markup)

                flow_source = (
                    "domain1.com 301 ke domainb.com\n"
                    "domain2.com 301 ke domainb.com"
                )
                saved_flow = server.save_seo_flow_schema(admin_id, flow_source)
                self.assertEqual(flow_source, saved_flow["source_text"])
                self.assertEqual(flow_source, server.load_seo_flow_schema(admin_id)["source_text"])
                self.assertEqual("", server.load_seo_flow_schema(admin2_id)["source_text"])
                workbook_bytes = server.export_seo_flow_xlsx(admin_id)
                self.assertTrue(workbook_bytes.startswith(b"PK"))
                with zipfile.ZipFile(io.BytesIO(workbook_bytes)) as workbook:
                    self.assertIn("xl/worksheets/sheet1.xml", workbook.namelist())
                    self.assertIn("xl/worksheets/sheet2.xml", workbook.namelist())
                    redirect_sheet = workbook.read("xl/worksheets/sheet1.xml").decode("utf-8")
                    summary_sheet = workbook.read("xl/worksheets/sheet2.xml").decode("utf-8")
                    self.assertIn("domain1.com", redirect_sheet)
                    self.assertIn("domainb.com", redirect_sheet)
                    self.assertIn("COUNTIF", summary_sheet)
                    for name in workbook.namelist():
                        if name.endswith(".xml"):
                            ElementTree.fromstring(workbook.read(name))

                api_key = "sk-test-" + ("x" * 32)
                saved_connection = server.save_ai_connection(admin_id, {
                    "provider": "openai",
                    "model": "gpt-test-model",
                    "api_key": api_key,
                })
                self.assertTrue(saved_connection["configured"])
                self.assertNotIn(api_key, str(saved_connection))
                self.assertFalse(server.public_ai_connection(admin2_id)["configured"])
                with server.db() as connection:
                    encrypted = connection.execute(
                        "SELECT api_key_encrypted FROM ai_connections WHERE user_id = ?",
                        (admin_id,),
                    ).fetchone()["api_key_encrypted"]
                self.assertNotIn(api_key, encrypted)
                with mock.patch.object(
                    server,
                    "urlopen",
                    return_value=FakeOpenAIResponse("gpt-test-model"),
                ):
                    tested = server.test_ai_connection(admin_id)
                self.assertEqual("connected", tested["connection"]["connection_status"])

                ai_project = server.save_project({
                    "domain_url": "ai-content.test",
                    "keywords": "GAN89, GAN89 Login, GAN89 Daftar",
                    "cta_url": "https://ai-content.test/",
                    "use_ai_content": True,
                    "ai_content_mode": "rewrite",
                    "ai_instructions": "Gunakan gaya profesional.",
                }, admin_id)
                with mock.patch.object(
                    server,
                    "urlopen",
                    return_value=FakeOpenAIContentResponse("gpt-test-model"),
                ) as ai_request:
                    generated_ai_project = server.apply_ai_content_to_project(ai_project)
                self.assertEqual("GAN89 Panduan Unik untuk Domain Pengujian", generated_ai_project["seo_title"])
                self.assertEqual(5, len(server.generated_faqs(generated_ai_project)))
                self.assertEqual(5, len(server.generated_reviews(generated_ai_project)))
                self.assertEqual("openai", generated_ai_project["ai_content_json"]["report"]["source"])
                request_body = json.loads(ai_request.call_args.args[0].data.decode("utf-8"))
                self.assertEqual("json_schema", request_body["text"]["format"]["type"])
                self.assertNotIn("verbosity", request_body["text"])
                self.assertFalse(request_body["store"])
                with server.db() as connection:
                    connection.execute("DELETE FROM projects WHERE id = ?", (ai_project["id"],))

                first = server.save_project({"domain_url": "same-domain.test"}, admin_id)
                second = server.save_project({"domain_url": "same-domain.test"}, admin2_id)

                self.assertNotEqual(first["id"], second["id"])
                self.assertEqual([first["id"]], [item["id"] for item in server.list_projects(admin_id)])
                self.assertEqual([second["id"]], [item["id"] for item in server.list_projects(admin2_id)])
                self.assertIsNone(server.load_project(first["id"], admin2_id))
                self.assertNotEqual(
                    server.generated_paths(first)["folder"],
                    server.generated_paths(second)["folder"],
                )

                upload = [{
                    "filename": "logo.png",
                    "content_type": "image/png",
                    "payload": b"test-image",
                }]
                first_media = server.save_uploaded_media(upload, admin_id)[0]
                second_media = server.save_uploaded_media(upload, admin2_id)[0]
                self.assertEqual([first_media["id"]], [item["id"] for item in server.list_media(admin_id)])
                self.assertEqual([second_media["id"]], [item["id"] for item in server.list_media(admin2_id)])

                first_group = server.save_media_group({
                    "name": "Media Group A",
                    "logo_media_id": first_media["id"],
                    "icon_media_id": first_media["id"],
                    "main_media_id": first_media["id"],
                }, admin_id)
                second_group = server.save_media_group({
                    "name": "Media Group A",
                    "logo_media_id": second_media["id"],
                    "icon_media_id": second_media["id"],
                    "main_media_id": second_media["id"],
                }, admin2_id)
                self.assertNotEqual(first_group["id"], second_group["id"])
                self.assertEqual(1, len(server.list_media_groups(admin_id)))
                self.assertEqual(1, len(server.list_media_groups(admin2_id)))

                with self.assertRaisesRegex(ValueError, "Media tidak ditemukan"):
                    server.delete_media_asset(first_media["id"], admin2_id)


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