import os
import logging
import gradio as gr
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_openai import ChatOpenAI # Use this for OpenRouter
# Remove ChatPromptTemplate import as we'll bypass it for system message
from langchain_core.output_parsers import StrOutputParser
from langchain_core.messages import HumanMessage, SystemMessage
# Import HumanMessagePromptTemplate if needed for other parts, but not for this fix
import requests
import tempfile
import json
import re # Import regex for parsing

logging.basicConfig(level=logging.INFO)

# --- Constants & Prompts ---

# Expanded Gemini Model List based on user feedback
VALID_GEMINI_MODELS = [
    "gemini-1.5-pro-latest", # Default/Recommended
    "gemini-1.5-flash-latest",
    "gemini-2.5-flash-preview-04-17", # Added
    "gemini-2.5-pro-preview-03-25", # Added
    "gemini-2.0-flash", # Added
    "gemini-2.0-flash-lite", # Added
]

# Define the *significantly enhanced* prompt template for detailed tasks
# Escape literal curly braces by doubling them {{ and }} - This is kept for clarity but won't be parsed by Langchain in the new approach
system_prompt_base = """You are an expert AI assistant specialized in breaking down software development ideas into **extremely detailed, actionable, step-by-step tasks** for AI-powered coding tools. The user will provide an application idea, a target AI tool, and a desired language (Turkish or English). Your goal is to generate a comprehensive, multi-page plan that the AI tool can follow precisely to build the application.

**Output Requirements:**
1.  **Language:** Generate the entire response in the requested language ({language}).
2.  **Format:** Use a numbered list for the main steps. Use sub-bullets (multiple levels if necessary) for intricate details within each step.
3.  **Detail Level:** Be **extremely specific and verbose**. The output should be **at least two pages long** when rendered normally. Include:
    *   **Project Setup:** Detailed commands for project initialization (e.g., `npx create-next-app`, `python -m venv venv`), including specific options to select.
    *   **Project Structure:** Define the complete directory and file structure, explaining the purpose of key files/folders.
    *   **Libraries/Dependencies:** List all necessary libraries and exact installation commands (e.g., `npm install react react-dom axios` or `pip install flask sqlalchemy flask-cors`).
    *   **Code Snippets/Examples:** Provide **concrete example code snippets** for key functions, components, or configurations. Do not just describe; show the code.
    *   **Configuration:** Detail necessary configuration files (e.g., `.env`, `tailwind.config.js`, `database.py`) and provide example settings.
    *   **Step-by-Step Instructions:** Break down every complex task into the smallest possible, manageable sub-steps. Leave no ambiguity.
    *   **AI Tool Prompts:** Suggest **very specific, context-rich prompts** the user could give to the target AI tool for each significant code generation or modification step (e.g., "Cursor, in `src/components/AuthForm.js`, generate a React functional component named `AuthForm`. It should include state variables for `email`, `password`, and `isLoading`. Add input fields for email and password, and a submit button. Implement basic form handling with `onSubmit` that logs the email and password for now. Use Tailwind CSS for styling.").
4.  **Logical Flow:** Ensure tasks are sequential, logical, and build upon each other seamlessly.
5.  **Completeness:** Cover the entire development lifecycle from setup to basic implementation of core features.

**Target AI Tool Guidance:**
*   **Cursor:** Focus on tasks involving code generation, refactoring, debugging within an IDE context, using codebase awareness. Emphasize prompts for generating functions, classes, components, files, and modifying existing code based on context.
*   **Windsurf:** Assume tasks related to web development (React/Next.js focus). Include detailed prompts for UI generation, component creation (with props and state), styling (e.g., Tailwind CSS classes), API integration, and data fetching logic.
*   **TRAE AI, CLINE, ROOCODE:** Treat as advanced code generation/completion tools. Provide highly detailed instructions for setting up project structure, defining data models/schemas (e.g., SQL table definitions, ORM models), implementing complex core logic (functions, classes, algorithms), creating API endpoints (with request/response examples), generating UI components, and writing unit/integration tests. Specify extremely detailed prompts for each generation step.
*   **Genel (General):** Provide a comprehensive software development plan covering requirements analysis, detailed architecture design (including technology stack choices, database schema design), meticulous implementation steps for all major features, testing strategy (unit, integration, e2e), and deployment considerations. Maintain an exceptionally high level of detail suitable for guiding a development team.

**Example Task Structure (Illustrative - More Detail Needed in Actual Output):**
1.  **Project Setup (Next.js Blog):**
    *   Open your terminal.
    *   Navigate to your desired projects directory.
    *   Run the command: `npx create-next-app@latest my-detailed-blog`
    *   When prompted:
        *   Select `Yes` for TypeScript.
        *   Select `Yes` for ESLint.
        *   Select `Yes` for Tailwind CSS.
        *   Select `Yes` for `src/` directory.
        *   Select `Yes` for App Router.
        *   Select `No` for customizing the default import alias.
    *   Navigate into the project: `cd my-detailed-blog`
    *   Verify the structure (show key folders like `src/app`, `src/lib`, `public`, `tailwind.config.ts`).
2.  **Install Dependencies:**
    *   Run: `npm install gray-matter react-markdown date-fns`
    *   Explain purpose: `gray-matter` for frontmatter, `react-markdown` for rendering, `date-fns` for date formatting.
3.  **Define Blog Post Structure & Content:**
    *   Create a directory: `mkdir content` at the project root.
    *   Inside `content`, create `posts` directory: `mkdir content/posts`
    *   Create an example post file: `content/posts/first-post.md`
    *   Add content with frontmatter:
        ```markdown
        ---
        title: "My First Detailed Post"
        date: "2025-05-01"
        author: "AI Assistant"
        excerpt: "This is a short summary of the post..."
        ---

        ## Introduction

        This is the main content of the blog post, written in Markdown.

        *   You can use lists.
        *   And other Markdown features.

        ```python
        print("Hello, World!")
        ```
        ```
4.  **Implement Post Utility Functions (`src/lib/posts.ts`):**
    *   Create the file: `src/lib/posts.ts`
    *   **Prompt for AI Tool (Cursor):** "In `src/lib/posts.ts`, generate the following TypeScript functions:
        1.  `getPostsDirectory()`: Returns the absolute path to the `content/posts` directory.
        2.  `getAllPostIds()`: Reads all filenames in the posts directory and returns an array of objects like `{{ params: {{ id: 'first-post' }} }}` (without the `.md` extension), suitable for Next.js `generateStaticParams`.
        3.  `getPostData(id: string)`: Takes a post ID (filename without extension), reads the corresponding `.md` file, parses the frontmatter using `gray-matter`, converts the markdown content to HTML using `react-markdown` (or keep as markdown string if rendering client-side), formats the date using `date-fns`, and returns an object containing `id`, `title`, `date`, `author`, `excerpt`, and `contentHtml` (or `contentMarkdown`). Handle potential file read errors.
        4.  `getSortedPostsData()`: Reads all posts, parses frontmatter, and returns an array of post metadata (`id`, `title`, `date`, `author`, `excerpt`) sorted by date in descending order."
    *   Add necessary imports: `fs`, `path`, `gray-matter`, `date-fns`.
5.  **Create Blog Index Page (`src/app/page.tsx`):**
    *   Clear the default content of `src/app/page.tsx`.
    *   **Prompt for AI Tool (Cursor/Windsurf):** "Update `src/app/page.tsx` to be an async Server Component. Import `getSortedPostsData` from `src/lib/posts`. Call `getSortedPostsData` to fetch the sorted post metadata. Render a heading 'Blog'. Below the heading, map over the sorted posts data and render a list (`<ul>`). Each list item (`<li>`) should contain:
        *   A link (`<Link href={{`/posts/${{post.id}}`}}>`) displaying the `post.title`.
        *   A small text element displaying the formatted `post.date` and `post.author`.
        *   The `post.excerpt` below the title/date.
        *   Use Tailwind CSS classes for styling (e.g., `text-2xl font-bold`, `text-gray-600`, `mt-2`). Import `Link` from `next/link`."
6.  **Create Dynamic Post Page (`src/app/posts/[id]/page.tsx`):**
    *   Create the directory structure: `src/app/posts/[id]`
    *   Create the file: `src/app/posts/[id]/page.tsx`
    *   **Prompt for AI Tool (Cursor/Windsurf):** "Create `src/app/posts/[id]/page.tsx`. Implement the following:
        1.  Import `getAllPostIds` and `getPostData` from `src/lib/posts`.
        2.  Implement `generateStaticParams` using `getAllPostIds` to pre-render all post pages at build time.
        3.  Define the page component as an async function `Post({{ params }}: {{ params: {{ id: string }} }})`.
        4.  Inside the component, call `getPostData(params.id)` to fetch the specific post data.
        5.  Render the post content:
            *   An `<h1>` with the `post.title`.
            *   A `<div>` with the `post.date` and `post.author`.
            *   A `<div>` where the `post.contentHtml` (or markdown content rendered with `react-markdown`) is displayed. Use Tailwind's `prose` classes for styling the markdown content if applicable.
        6.  Add basic error handling if post data is not found."
7.  ... (Continue with styling refinements, layout component, potential API routes, etc. - BE EXTREMELY DETAILED)

Now, generate the **highly detailed, multi-page** task list based on the user's request below. Ensure the output is in **{language}** and includes **example code snippets**.
"""

output_parser = StrOutputParser()

# --- API Key & Model Management ---

def validate_gemini_key(api_key):
    """Validates a Gemini API key by making a simple list_models call."""
    if not api_key:
        return False, "API anahtarı boş."
    try:
        llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash-latest", google_api_key=api_key, client_options={"api_endpoint": "generativelanguage.googleapis.com"})
        llm.invoke([HumanMessage(content="Hi")])
        logging.info("Gemini API key validated successfully.")
        return True, "Başarıyla Doğrulandı"
    except Exception as e:
        logging.error(f"Gemini API key validation failed: {e}")
        if "API_KEY_INVALID" in str(e):
             return False, f"Doğrulama Başarısız: Geçersiz API Anahtarı."
        if "models/gemini-pro" in str(e) or "is not found for API version" in str(e):
             return False, f"Doğrulama Başarısız: Eski model desteklenmiyor olabilir. Geçerli bir model seçin."
        return False, f"Doğrulama Başarısız: {e}"

def validate_openrouter_key(api_key):
    """Validates an OpenRouter API key by making a simple call."""
    if not api_key:
        return False, "API anahtarı boş."
    try:
        response = requests.get(
            "https://openrouter.ai/api/v1/auth/key",
            headers={"Authorization": f"Bearer {api_key}"}
        )
        response.raise_for_status()
        logging.info("OpenRouter API key validated successfully.")
        return True, "Başarıyla Doğrulandı"
    except requests.exceptions.RequestException as e:
        logging.error(f"OpenRouter API key validation failed: {e}")
        status_code = e.response.status_code if e.response is not None else "N/A"
        if status_code == 401:
            return False, f"Doğrulama Başarısız (HTTP {status_code}): Geçersiz API Anahtarı."
        return False, f"Doğrulama Başarısız (HTTP {status_code}): {e}"
    except Exception as e:
        logging.error(f"OpenRouter API key validation failed with unexpected error: {e}")
        return False, f"Doğrulama Başarısız: {e}"

def save_api_key(api_key, api_type):
    """Validates and saves the API key to the state."""
    if api_type == "gemini":
        is_valid, status_message = validate_gemini_key(api_key)
    elif api_type == "openrouter":
        is_valid, status_message = validate_openrouter_key(api_key)
    else:
        return None, "Geçersiz API Tipi"

    if is_valid:
        return api_key, status_message
    else:
        return None, status_message

def delete_api_key(api_type):
    """Deletes the API key from the state."""
    logging.info(f"Deleting {api_type} API key from state.")
    return None, "Kaydedilmedi", ""

def list_available_gemini_models():
    """Returns the updated list of predefined Gemini models."""
    logging.info("Returning updated predefined Gemini models list.")
    return VALID_GEMINI_MODELS

def list_available_openrouter_models():
    """Lists available models from OpenRouter API and returns a list."""
    try:
        logging.info("Fetching OpenRouter models...")
        response = requests.get("https://openrouter.ai/api/v1/models")
        response.raise_for_status()
        models_data = response.json().get("data", [])
        preferred_vendors = ["google", "anthropic", "openai", "mistralai", "meta-llama"]
        models = sorted(
            [m["id"] for m in models_data],
            key=lambda x: ([p not in x.lower() for p in preferred_vendors], x)
        )
        logging.info(f"Fetched {len(models)} OpenRouter models.")
        if not models:
            models = ["google/gemini-pro"] # Fallback
        return models
    except requests.exceptions.RequestException as e:
        logging.error(f"Error fetching OpenRouter models: {e}")
        gr.Warning(f"OpenRouter modelleri listelenemedi: {e}")
        return ["google/gemini-pro"] # Fallback list
    except Exception as e:
        logging.error(f"Error processing OpenRouter models: {e}")
        gr.Warning(f"OpenRouter modelleri işlenirken hata: {e}")
        return ["google/gemini-pro"] # Fallback list

# --- Task Generation Logic ---



def get_llm(gemini_key, openrouter_key, gemini_model_name, openrouter_model_name):
    """Initializes and returns the appropriate LLM based on provided keys and model names."""
    # --- Enhanced Debugging: Log received keys ---
    logging.info(f"get_llm received gemini_key: {'present' if gemini_key else 'None or empty'}")
    logging.info(f"get_llm received openrouter_key: {'present' if openrouter_key else 'None or empty'}")
    # -------------------------------------------
    llm = None
    api_used = None
    last_error = None
    gemini_error_details = None
    openrouter_error_details = None

    if gemini_key and gemini_model_name in VALID_GEMINI_MODELS:
        try:
            llm = ChatGoogleGenerativeAI(model=gemini_model_name, google_api_key=gemini_key, convert_system_message_to_human=True)
            logging.info(f"Attempting to use Gemini LLM ({gemini_model_name}).")
            llm.invoke([HumanMessage(content="Hi")])
            logging.info(f"Successfully initialized Gemini LLM ({gemini_model_name}).")
            api_used = "Gemini"
            return llm, api_used
        except Exception as e:
            logging.error(f"Failed to initialize Gemini ({gemini_model_name}): {e}")
            gemini_error_details = f"Gemini ({gemini_model_name}): {e}" # Store specific error
            llm = None # Ensure llm is None if Gemini fails
    elif gemini_key:
        logging.warning(f"Selected Gemini model 	{gemini_model_name}	 is not in the valid list. Skipping Gemini.")
        last_error = ValueError(f"Geçersiz Gemini modeli seçildi: {gemini_model_name}")

    if openrouter_key and llm is None:
        try:
            if not openrouter_model_name:
                raise ValueError("OpenRouter modeli seçilmedi.")
            llm = ChatOpenAI(
                model=openrouter_model_name,
                openai_api_key=openrouter_key,
                openai_api_base="https://openrouter.ai/api/v1",
            )
            logging.info(f"Attempting to use OpenRouter LLM ({openrouter_model_name}).")
            llm.invoke([HumanMessage(content="Hi")])
            logging.info(f"Successfully initialized OpenRouter LLM ({openrouter_model_name}).")
            api_used = "OpenRouter"
            return llm, api_used
        except Exception as e:
            logging.error(f"Failed to initialize OpenRouter ({openrouter_model_name}): {e}")
            openrouter_error_details = f"OpenRouter ({openrouter_model_name}): {e}" # Store specific error
            # Keep last_error logic for now, might refine later
            if last_error is None or not gemini_key:
                last_error = e

    if llm is None:
        # --- Improved Error Reporting ---
        error_messages = []
        if not gemini_key and not openrouter_key:
            error_messages.append("API anahtarı sağlanmadı.")
        else:
            if gemini_key and gemini_error_details:
                error_messages.append(f"Gemini Başlatılamadı: {gemini_error_details}")
            elif gemini_key and not gemini_error_details:
                 # This case might indicate a valid key but some other issue, or invalid model selection
                 if last_error and isinstance(last_error, ValueError) and "Geçersiz Gemini modeli" in str(last_error):
                     error_messages.append(str(last_error))
                 else:
                     error_messages.append(f"Gemini anahtarı sağlandı ancak LLM başlatılamadı (belirsiz hata: {last_error})")

            if openrouter_key and openrouter_error_details:
                error_messages.append(f"OpenRouter Başlatılamadı: {openrouter_error_details}")
            elif openrouter_key and not openrouter_error_details:
                # Similar case for OpenRouter
                if last_error and isinstance(last_error, ValueError) and "OpenRouter modeli seçilmedi" in str(last_error):
                    error_messages.append(str(last_error))
                else:
                    error_messages.append(f"OpenRouter anahtarı sağlandı ancak LLM başlatılamadı (belirsiz hata: {last_error})")

        if not error_messages:
             error_messages.append("LLM başlatılırken bilinmeyen bir hata oluştu.")

        # Combine error messages
        final_error_message = "LLM Başlatma Hatası: " + " | ".join(error_messages)
        logging.error(final_error_message) # Log the detailed error
        raise gr.Error(final_error_message) # Raise the detailed error to Gradio UI
        # --- End Improved Error Reporting ---
    else:
        return llm, api_used

def generate_tasks_for_idea(idea, gemini_key, openrouter_key, target_tool, gemini_model_name, openrouter_model_name, language):
    """Generates tasks based on an application idea using Langchain and an LLM, in the specified language."""
    logging.info(f"Generating tasks for idea: 	{idea[:50]}...	, Target Tool: {target_tool}, Language: {language}")

    if not idea:
        yield "Hata: Lütfen bir uygulama fikri girin."
        return

    if not gemini_key and not openrouter_key:
        yield "Hata: Lütfen en az bir API anahtarı (Gemini veya OpenRouter) girin."
        return

    try:
        llm, api_used = get_llm(gemini_key, openrouter_key, gemini_model_name, openrouter_model_name)
        logging.info(f"Successfully initialized LLM using {api_used}.")

        # --- Alternative Prompt Approach --- 
        # 1. Format the system prompt with the language
        formatted_system_prompt = system_prompt_base.format(language=language)
        
        # 2. Create the human message content
        human_message_content = f"Application Idea: {idea}\nTarget AI Tool: {target_tool}"
        
        # 3. Create the messages list manually
        messages = [
            SystemMessage(content=formatted_system_prompt),
            HumanMessage(content=human_message_content)
        ]
        # --- End of Alternative Approach ---

        logging.info("Invoking LLM directly with messages list...")
        # Invoke the LLM directly with the list of messages
        response_stream = llm.stream(messages)

        full_response = ""
        yield "Detaylı görevler oluşturuluyor, lütfen bekleyin...\n\n" # Initial message
        for chunk in response_stream:
            # Access the content attribute of the AIMessage chunk
            if hasattr(chunk, 'content'):
                full_response += chunk.content
                yield full_response
            else:
                # Handle potential non-AIMessage chunks if necessary (e.g., errors)
                logging.warning(f"Received unexpected chunk type: {type(chunk)}")

        logging.info("Detailed task generation complete.")

    except gr.Error as e:
        logging.error(f"Gradio Error during task generation: {e}")
        yield f"Hata: {e}"
    except Exception as e:
        # Check specifically for the template formatting error again (shouldn't happen now)
        if "unexpected '{' in field name" in str(e):
             logging.error(f"Template formatting error persisted unexpectedly: {e}", exc_info=True)
             yield f"Hata: Prompt şablonu hatası devam ediyor. Lütfen geliştiriciye bildirin. Hata: {e}"
        else:
             logging.error(f"Error during task generation: {e}", exc_info=True)
             yield f"Görev oluşturulurken bir hata oluştu: {e}. Lütfen API anahtarlarınızı, model seçiminizi ve ağ bağlantınızı kontrol edin."

# --- Task Downloading Logic ---

def format_tasks_for_download(tasks_text, file_format):
    """Formats the generated tasks text into the specified file format and returns the file path."""
    if not tasks_text or tasks_text.startswith("Detaylı görevler oluşturuluyor"):
        gr.Warning("İndirilecek geçerli görev bulunmuyor.")
        return None

    try:
        suffix = ".txt"
        content = tasks_text
        if file_format == "Markdown":
            suffix = ".md"
            content = tasks_text # Assume LLM output is already markdown
        elif file_format == "JSON":
            suffix = ".json"
            tasks_list = []
            current_task_lines = []
            task_pattern = re.compile(r"^\s*\d+\.\s+")

            for line in tasks_text.strip().split("\n"):
                line_strip = line.strip()
                if task_pattern.match(line_strip):
                    if current_task_lines:
                        tasks_list.append("\n".join(current_task_lines).strip())
                    current_task_lines = [task_pattern.sub("", line_strip)]
                elif line_strip or current_task_lines:
                    current_task_lines.append(line)

            if current_task_lines:
                tasks_list.append("\n".join(current_task_lines).strip())

            content = json.dumps({"tasks": tasks_list}, indent=4, ensure_ascii=False)

        with tempfile.NamedTemporaryFile(mode="w", suffix=suffix, delete=False, encoding="utf-8") as temp_file:
            temp_file.write(content)
            file_path = temp_file.name
            logging.info(f"Tasks formatted as {file_format} and saved to temporary file: {file_path}")
            return file_path

    except Exception as e:
        logging.error(f"Error formatting tasks for download: {e}")
        gr.Error(f"Görevler indirilirken hata oluştu: {e}")
        return None