import secrets
from pathlib import Path
from typing import List, Union

from pydantic import AnyHttpUrl, field_validator
from pydantic_settings import BaseSettings

import os

# Use correct path for database in production environment
# First try environment variable, then predefined paths
DB_PATH = os.environ.get("DB_PATH")
if DB_PATH:
    DB_DIR = Path(DB_PATH)
    print(f"Using database path from environment: {DB_DIR}")
else:
    # Try production path first, then local directories
    paths_to_try = [
        Path("/app/storage/db"),  # Primary production path with proper permissions
        Path("/app/storage"),  # Alternate storage path
        Path.cwd() / "storage/db",  # Local development path
        Path("/tmp/taskmanager"),  # Fallback path
    ]

    # Find the first writable path
    DB_DIR = None
    for path in paths_to_try:
        try:
            # Create directory with parents if it doesn't exist
            path.mkdir(parents=True, exist_ok=True)

            # Explicitly set permissions if possible (755 = rwxr-xr-x)
            try:
                import stat

                path_mode = (
                    stat.S_IRWXU
                    | stat.S_IRGRP
                    | stat.S_IXGRP
                    | stat.S_IROTH
                    | stat.S_IXOTH
                )
                os.chmod(path, path_mode)
            except Exception as chmod_err:
                print(f"Warning: Could not set permissions on {path}: {chmod_err}")

            # Test if it's writable
            test_file = path / ".write_test"
            test_file.touch()

            # Try to write to it
            with open(test_file, "w") as f:
                f.write("test")

            # Read back to verify
            with open(test_file, "r") as f:
                content = f.read()
                if content != "test":
                    raise Exception("Write verification failed")

            test_file.unlink()  # Remove the test file

            DB_DIR = path
            print(f"Using database path: {DB_DIR}")
            break
        except Exception as e:
            print(f"Cannot use path {path}: {e}")

    # Last resort fallback
    if DB_DIR is None:
        DB_DIR = Path("/tmp")
        print(f"Falling back to temporary directory: {DB_DIR}")
        try:
            Path("/tmp").mkdir(exist_ok=True)
        except Exception:
            pass


class Settings(BaseSettings):
    # Application settings
    PROJECT_NAME: str = "Task Manager API"
    API_PREFIX: str = ""
    SECRET_KEY: str = secrets.token_urlsafe(32)
    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8  # 8 days
    ENVIRONMENT: str = "development"

    # CORS Configuration
    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = []

    @field_validator("BACKEND_CORS_ORIGINS", mode="before")
    def assemble_cors_origins(cls, v: Union[str, List[str]]) -> Union[List[str], str]:
        if isinstance(v, str) and not v.startswith("["):
            return [i.strip() for i in v.split(",")]
        elif isinstance(v, (list, str)):
            return v
        raise ValueError(v)

    # Database configuration
    SQLALCHEMY_DATABASE_URL: str = f"sqlite:///{DB_DIR}/db.sqlite"

    # LLM provider settings - defaults to Mock service if not configured
    # Options: "openai", "gemini", "mock"
    LLM_PROVIDER: str = os.environ.get("LLM_PROVIDER", "gemini")
    
    # OpenAI settings
    OPENAI_API_KEY: str = os.environ.get("OPENAI_API_KEY", "")
    OPENAI_MODEL: str = os.environ.get("OPENAI_MODEL", "gpt-3.5-turbo")
    
    # Google Gemini settings
    GEMINI_API_KEY: str = os.environ.get("GEMINI_API_KEY", "AIzaSyBfGr0aHSV_Tp5_RwqyRhQWGTJDelBIdgY")
    GEMINI_MODEL: str = os.environ.get("GEMINI_MODEL", "gemini-2.0-flash")

    model_config = {"case_sensitive": True}


settings = Settings()