import zipfile
import io
import json
from typing import Dict, Any


def generate_export_package(
    chatbot: Dict[str, Any],
    company: Dict[str, Any],
    qdrant_url: str,
    qdrant_key: str,
) -> bytes:
    """
    Generate a complete export ZIP with FastAPI backend + React widget
    """
    buffer = io.BytesIO()

    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
        # ── Backend files ──────────────────────────────────────────
        zf.writestr("backend/requirements.txt", _requirements())
        zf.writestr("backend/.env.example", _env_example(chatbot, qdrant_url, qdrant_key))
        zf.writestr("backend/main.py", _main_py(chatbot))
        zf.writestr("backend/rag_engine.py", _rag_engine_py())
        zf.writestr("backend/Dockerfile", _dockerfile())
        zf.writestr("backend/docker-compose.yml", _docker_compose(chatbot))
        zf.writestr("backend/README.md", _backend_readme(chatbot))

        # ── Frontend files ─────────────────────────────────────────
        zf.writestr("frontend/src/ChatWidget.tsx", _chat_widget_tsx(chatbot))
        zf.writestr("frontend/src/useChat.ts", _use_chat_ts())
        zf.writestr("frontend/src/api.ts", _api_ts())
        zf.writestr("frontend/src/types.ts", _types_ts())
        zf.writestr("frontend/package.json", _package_json(chatbot))
        zf.writestr("frontend/tsconfig.json", _tsconfig())
        zf.writestr("frontend/vite.config.ts", _vite_config())
        zf.writestr("frontend/README.md", _frontend_readme(chatbot))

        # ── Root ───────────────────────────────────────────────────
        zf.writestr("QUICK_START.md", _quick_start(chatbot))
        zf.writestr("setup.py", _setup_wizard(chatbot))

    buffer.seek(0)
    return buffer.read()


def _requirements():
    return """fastapi==0.115.0
uvicorn[standard]==0.30.6
python-dotenv==1.0.1
pydantic==2.8.2
qdrant-client==1.11.1
openai==1.51.0
anthropic==0.34.2
google-generativeai==0.8.1
httpx==0.27.2
langdetect==1.0.9
"""


# BUG-14 FIX: Helper to safely escape strings for use in generated Python code
def _escape_for_python(value: str) -> str:
    """Escape a string so it can be safely embedded in generated Python source code.
    Uses json.dumps which properly escapes quotes, backslashes, and special chars."""
    return json.dumps(value)


def _env_example(chatbot: Dict, qdrant_url: str, qdrant_key: str):
    name = chatbot.get("name", "My Chatbot").upper().replace(" ", "_")
    return f"""# {name} - Environment Configuration
# Copy to .env and fill in your values

# LLM Provider (choose one)
LLM_PROVIDER=openai
LLM_MODEL=gpt-4o
LLM_API_KEY=sk-your-openai-key

# For Anthropic: sk-ant-your-key
# For Google: your-google-api-key
# For Fireworks: your-fireworks-key

# Embeddings (required - OpenAI)
EMBEDDING_API_KEY=sk-your-openai-key
EMBEDDING_MODEL=text-embedding-3-small

# Qdrant Vector Database
QDRANT_URL={qdrant_url}
QDRANT_API_KEY={qdrant_key}
QDRANT_COLLECTION={chatbot.get("qdrant_collection_name", "chatbot_collection")}

# Server
PORT=8000
HOST=0.0.0.0
ALLOWED_ORIGINS=http://localhost:3000,https://yourdomain.com
"""


def _main_py(chatbot: Dict):
    # BUG-14 FIX: Use json.dumps to safely escape system_prompt
    # Previously used f-string with triple quotes, which broke if prompt contained """ or {
    safe_name = _escape_for_python(chatbot.get("name", "Chatbot"))
    safe_prompt = _escape_for_python(chatbot.get("system_prompt") or "You are a helpful assistant.")

    return f'''"""
Auto-generated FastAPI backend for: {chatbot.get("name", "Chatbot")}
Generated by Contexta Platform
"""
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import List, Optional
import os
from dotenv import load_dotenv
from rag_engine import RAGEngine

load_dotenv()

# BUG-14 FIX: System prompt stored safely via json-escaped string
SYSTEM_PROMPT = {safe_prompt}

app = FastAPI(
    title={safe_name} + " API",
    version="1.0.0"
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=os.getenv("ALLOWED_ORIGINS", "*").split(","),
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

rag = RAGEngine(
    qdrant_url=os.getenv("QDRANT_URL"),
    qdrant_api_key=os.getenv("QDRANT_API_KEY"),
    collection_name=os.getenv("QDRANT_COLLECTION"),
    llm_provider=os.getenv("LLM_PROVIDER", "openai"),
    llm_model=os.getenv("LLM_MODEL", "gpt-4o"),
    llm_api_key=os.getenv("LLM_API_KEY"),
    embedding_api_key=os.getenv("EMBEDDING_API_KEY"),
    embedding_model=os.getenv("EMBEDDING_MODEL", "text-embedding-3-small"),
    system_prompt=SYSTEM_PROMPT,
)


class ChatRequest(BaseModel):
    message: str
    session_id: Optional[str] = None
    language: str = "en"
    history: List[dict] = []


class Source(BaseModel):
    document_name: str
    text: str
    score: float


class ChatResponse(BaseModel):
    response: str
    session_id: str
    sources: List[Source]


@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    import uuid
    session_id = request.session_id or str(uuid.uuid4())
    result = await rag.query(
        query=request.message,
        history=request.history,
        language=request.language,
    )
    return ChatResponse(
        response=result["response"],
        session_id=session_id,
        sources=[Source(**s) for s in result.get("sources", [])],
    )


@app.get("/health")
def health():
    return {{"status": "healthy", "chatbot": {safe_name}}}


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host=os.getenv("HOST", "0.0.0.0"), port=int(os.getenv("PORT", 8000)))
'''


def _rag_engine_py():
    return '''"""RAG Engine - Retrieval-Augmented Generation"""
from qdrant_client import QdrantClient
from qdrant_client.http.models import Distance, VectorParams
from openai import AsyncOpenAI
from typing import List, Dict, Any, Optional
import logging

logger = logging.getLogger(__name__)


class RAGEngine:
    def __init__(self, qdrant_url, qdrant_api_key, collection_name,
                 llm_provider, llm_model, llm_api_key,
                 embedding_api_key, embedding_model, system_prompt):
        self.collection_name = collection_name
        self.llm_provider = llm_provider
        self.llm_model = llm_model
        self.llm_api_key = llm_api_key
        self.system_prompt = system_prompt
        self.embedding_model = embedding_model

        # Initialize Qdrant
        self.qdrant = QdrantClient(url=qdrant_url, api_key=qdrant_api_key)

        # Initialize embedding client
        self.embed_client = AsyncOpenAI(api_key=embedding_api_key)

    async def _get_embedding(self, text: str) -> List[float]:
        response = await self.embed_client.embeddings.create(
            model=self.embedding_model,
            input=text,
        )
        return response.data[0].embedding

    async def _search_vectors(self, query_embedding: List[float], top_k: int = 5) -> List[Dict]:
        results = self.qdrant.search(
            collection_name=self.collection_name,
            query_vector=query_embedding,
            limit=top_k,
        )
        return [
            {
                "document_name": r.payload.get("document_name", "Unknown"),
                "text": r.payload.get("text", ""),
                "score": r.score,
            }
            for r in results
        ]

    async def query(self, query: str, history: List[Dict] = None, language: str = "en") -> Dict:
        # Get embedding for query
        query_embedding = await self._get_embedding(query)

        # Search for relevant chunks
        sources = await self._search_vectors(query_embedding)

        # Build context from sources
        context = "\\n\\n".join([
            f"[Source: {s['document_name']}]\\n{s['text']}"
            for s in sources
        ])

        # Build messages
        messages = [
            {"role": "system", "content": f"{self.system_prompt}\\n\\nUse the following context to answer:\\n{context}"},
        ]

        if history:
            messages.extend(history[-10:])

        messages.append({"role": "user", "content": query})

        # Generate response based on provider
        response_text = await self._generate(messages)

        return {
            "response": response_text,
            "sources": sources,
        }

    async def _generate(self, messages: List[Dict]) -> str:
        if self.llm_provider == "openai":
            from openai import AsyncOpenAI
            client = AsyncOpenAI(api_key=self.llm_api_key)
            response = await client.chat.completions.create(
                model=self.llm_model,
                messages=messages,
                max_tokens=1000,
            )
            return response.choices[0].message.content

        elif self.llm_provider == "anthropic":
            import anthropic
            client = anthropic.AsyncAnthropic(api_key=self.llm_api_key)
            system = messages[0]["content"]
            msgs = [m for m in messages[1:] if m["role"] in ("user", "assistant")]
            response = await client.messages.create(
                model=self.llm_model,
                max_tokens=1000,
                system=system,
                messages=msgs,
            )
            return response.content[0].text

        elif self.llm_provider == "google":
            import google.generativeai as genai
            genai.configure(api_key=self.llm_api_key)
            model = genai.GenerativeModel(self.llm_model)
            prompt = "\\n".join([f"{m['role']}: {m['content']}" for m in messages])
            response = await model.generate_content_async(prompt)
            return response.text

        else:
            import httpx
            headers = {"Authorization": f"Bearer {self.llm_api_key}", "Content-Type": "application/json"}
            async with httpx.AsyncClient(timeout=60) as client:
                resp = await client.post(
                    "https://api.fireworks.ai/inference/v1/chat/completions",
                    headers=headers,
                    json={"model": self.llm_model, "messages": messages, "max_tokens": 1000},
                )
                resp.raise_for_status()
                return resp.json()["choices"][0]["message"]["content"]
'''


def _dockerfile():
    return """FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .

EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
"""


def _docker_compose(chatbot: Dict):
    name = chatbot.get("name", "chatbot").lower().replace(" ", "-")
    return f"""version: "3.8"
services:
  api:
    build: .
    container_name: {name}-api
    ports:
      - "${{PORT:-8000}}:8000"
    env_file:
      - .env
    restart: unless-stopped
"""


def _chat_widget_tsx(chatbot: Dict):
    safe_name = json.dumps(chatbot.get("name", "Chatbot"))
    safe_welcome = json.dumps(chatbot.get("welcome_message", "Hello! How can I help you?"))
    color = chatbot.get("primary_color", "#6366f1")
    return f'''import React, {{ useState }} from "react";
import {{ useChat }} from "./useChat";

export const ChatWidget: React.FC = () => {{
  const [isOpen, setIsOpen] = useState(false);
  const {{ messages, isLoading, sendMessage }} = useChat({safe_welcome});
  const [input, setInput] = useState("");

  const handleSend = () => {{
    if (!input.trim() || isLoading) return;
    sendMessage(input.trim());
    setInput("");
  }};

  return (
    <>
      {{isOpen && (
        <div style={{{{ position: "fixed", bottom: 80, right: 20, width: 380, height: 500,
          borderRadius: 16, overflow: "hidden", boxShadow: "0 8px 30px rgba(0,0,0,0.15)",
          display: "flex", flexDirection: "column", background: "#fff", zIndex: 9999 }}}}>
          <div style={{{{ background: "{color}", color: "#fff", padding: "12px 16px",
            fontWeight: 600, fontSize: 14 }}}}>
            {safe_name}
          </div>
          <div style={{{{ flex: 1, overflowY: "auto", padding: 12 }}}}>
            {{messages.map((m, i) => (
              <div key={{i}} style={{{{ display: "flex", justifyContent: m.role === "user" ? "flex-end" : "flex-start", marginBottom: 8 }}}}>
                <div style={{{{ background: m.role === "user" ? "{color}" : "#f3f4f6",
                  color: m.role === "user" ? "#fff" : "#1f2937",
                  borderRadius: 12, padding: "8px 12px", maxWidth: "80%", fontSize: 13 }}}}>
                  {{m.content}}
                </div>
              </div>
            ))}}
            {{isLoading && <div style={{{{ color: "#9ca3af", fontSize: 12 }}}}>Typing...</div>}}
          </div>
          <div style={{{{ borderTop: "1px solid #e5e7eb", padding: 8, display: "flex", gap: 8 }}}}>
            <input value={{input}} onChange={{e => setInput(e.target.value)}}
              onKeyDown={{e => e.key === "Enter" && handleSend()}}
              placeholder="Type a message..." style={{{{ flex: 1, border: "1px solid #d1d5db",
              borderRadius: 8, padding: "6px 10px", fontSize: 13, outline: "none" }}}} />
            <button onClick={{handleSend}} disabled={{isLoading}}
              style={{{{ background: "{color}", color: "#fff", border: "none", borderRadius: 8,
              padding: "6px 14px", cursor: "pointer", fontSize: 13 }}}}>Send</button>
          </div>
        </div>
      )}}
      <button onClick={{() => setIsOpen(!isOpen)}} style={{{{ position: "fixed", bottom: 20,
        right: 20, width: 56, height: 56, borderRadius: 28, background: "{color}",
        color: "#fff", border: "none", cursor: "pointer", fontSize: 24, zIndex: 9999,
        boxShadow: "0 4px 12px rgba(0,0,0,0.15)", display: "flex", alignItems: "center",
        justifyContent: "center" }}}}>
        {{isOpen ? "\\u00d7" : "\\ud83d\\udcac"}}
      </button>
    </>
  );
}};
'''


def _use_chat_ts():
    return '''import { useState, useCallback } from "react";
import { sendChatMessage } from "./api";

interface Message {
  role: "user" | "assistant";
  content: string;
}

export function useChat(welcomeMessage: string) {
  const [messages, setMessages] = useState<Message[]>([
    { role: "assistant", content: welcomeMessage }
  ]);
  const [isLoading, setIsLoading] = useState(false);
  const [sessionId] = useState(() => crypto.randomUUID());

  const sendMessage = useCallback(async (content: string) => {
    setMessages(prev => [...prev, { role: "user", content }]);
    setIsLoading(true);
    try {
      const history = messages.map(m => ({ role: m.role, content: m.content }));
      const result = await sendChatMessage({ message: content, session_id: sessionId, history });
      setMessages(prev => [...prev, { role: "assistant", content: result.response }]);
    } catch {
      setMessages(prev => [...prev, { role: "assistant", content: "Sorry, I encountered an error. Please try again." }]);
    } finally {
      setIsLoading(false);
    }
  }, [messages, sessionId]);

  return { messages, isLoading, sendMessage };
}
'''


def _api_ts():
    return '''const API_URL = import.meta.env.VITE_API_URL || "http://localhost:8000";

export async function sendChatMessage(payload: {
  message: string;
  session_id: string;
  history?: any[];
}) {
  const response = await fetch(`${API_URL}/chat`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });
  if (!response.ok) throw new Error("Chat request failed");
  return response.json();
}
'''


def _types_ts():
    return '''export interface Message {
  role: "user" | "assistant";
  content: string;
}

export interface Source {
  document_name: string;
  text: string;
  score: number;
}

export interface ChatResponse {
  response: string;
  session_id: string;
  sources: Source[];
}
'''


def _package_json(chatbot: Dict):
    name = chatbot.get("name", "chatbot").lower().replace(" ", "-")
    # Sanitize name for package.json
    safe_name = "".join(c for c in name if c.isalnum() or c == "-")
    return f'''{{
  "name": "{safe_name}-widget",
  "version": "1.0.0",
  "scripts": {{
    "dev": "vite",
    "build": "tsc && vite build",
    "preview": "vite preview"
  }},
  "dependencies": {{
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  }},
  "devDependencies": {{
    "@types/react": "^18.2.0",
    "@types/react-dom": "^18.2.0",
    "typescript": "^5.0.0",
    "vite": "^5.0.0",
    "@vitejs/plugin-react": "^4.0.0"
  }}
}}
'''


def _tsconfig():
    return '''{
  "compilerOptions": {
    "target": "ES2020",
    "lib": ["ES2020", "DOM"],
    "module": "ESNext",
    "moduleResolution": "bundler",
    "jsx": "react-jsx",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}
'''


def _vite_config():
    return '''import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";

export default defineConfig({
  plugins: [react()],
  build: {
    lib: {
      entry: "src/main.tsx",
      name: "ChatWidget",
      fileName: "chatbot-widget"
    },
    rollupOptions: {
      external: ["react", "react-dom"],
    }
  }
});
'''


def _backend_readme(chatbot: Dict):
    return f"""# {chatbot.get("name", "Chatbot")} - Backend API

## Quick Start

```bash
cp .env.example .env
# Edit .env with your API keys
pip install -r requirements.txt
uvicorn main:app --reload --port 8000
```

## Deploy with Docker

```bash
cp .env.example .env
# Edit .env
docker-compose up -d
```

## API Endpoints

- `POST /chat` - Send a message
- `GET /health` - Health check

## Environment Variables

See `.env.example` for all required variables.
"""


def _frontend_readme(chatbot: Dict):
    return f"""# {chatbot.get("name", "Chatbot")} - Chat Widget

## Quick Start

```bash
npm install
npm run dev
```

Create a `.env` file:
```
VITE_API_URL=http://localhost:8000
```

## Build for Production

```bash
npm run build
```

The built files will be in `dist/`.

## Embed in Your Website

```html
<script src="path/to/dist/chatbot-widget.js"></script>
```
"""


def _quick_start(chatbot: Dict):
    return f"""# {chatbot.get("name", "Chatbot")} - Quick Start Guide

## Prerequisites

- Python 3.11+
- Node.js 18+ (for the widget)

## Step 1: Backend Setup (2 minutes)

```bash
cd backend
cp .env.example .env
# Edit .env with your API keys
pip install -r requirements.txt
uvicorn main:app --reload
```

Visit http://localhost:8000/health to verify.

## Step 2: Frontend Setup (1 minute)

```bash
cd frontend
npm install
echo "VITE_API_URL=http://localhost:8000" > .env
npm run dev
```

## Step 3: Test It!

Open http://localhost:5173 and start chatting!

## Deployment

See `backend/README.md` and `frontend/README.md` for deployment guides.
"""


def _setup_wizard(chatbot: Dict):
    return f'''#!/usr/bin/env python3
"""Interactive setup wizard for {chatbot.get("name", "Chatbot")}"""
import os
import sys

def main():
    print("=" * 50)
    print(f"  Setup Wizard: {chatbot.get("name", "Chatbot")}")
    print("=" * 50)
    print()

    env_vars = {{}}

    # LLM Provider
    print("Choose your LLM provider:")
    print("  1. OpenAI (GPT-4o, GPT-4 Turbo)")
    print("  2. Anthropic (Claude 3.5 Sonnet)")
    print("  3. Google (Gemini 1.5 Pro)")
    print("  4. Fireworks AI (Llama, Mixtral)")
    choice = input("Enter choice [1]: ").strip() or "1"

    providers = {{"1": "openai", "2": "anthropic", "3": "google", "4": "fireworks"}}
    env_vars["LLM_PROVIDER"] = providers.get(choice, "openai")

    env_vars["LLM_API_KEY"] = input(f"Enter {{env_vars['LLM_PROVIDER']}} API key: ").strip()
    env_vars["EMBEDDING_API_KEY"] = input("Enter OpenAI API key (for embeddings): ").strip() or env_vars["LLM_API_KEY"]

    # Write .env
    env_path = os.path.join("backend", ".env")
    with open(env_path, "w") as f:
        for k, v in env_vars.items():
            f.write(f"{{k}}={{v}}\\n")

    print(f"\\nConfiguration saved to {{env_path}}")
    print("\\nTo start: cd backend && uvicorn main:app --reload")

if __name__ == "__main__":
    main()
'''