import sqlite3
import products, recipes, db, meals, persons, ingredients, shopping
import datetime

from pydantic import BaseModel
from typing import List, Annotated, Optional, Union
from fastapi import FastAPI, Depends, Query, Cookie
from fastapi.responses import JSONResponse
from fastapi.encoders import jsonable_encoder

app = FastAPI()

import os
DATABASE_PATH = os.environ.get('DOOF_DB', './data/doof.sqlite')

# Dependency to create SQLite connection
async def get_db():
    sql_db = await db.connect(DATABASE_PATH)
    try:
        yield sql_db
    finally:
        await sql_db.close()

async def cookie_person(user_id: Annotated[int, Cookie(alias='user_id')], conn: sqlite3.Connection = Depends(get_db)) -> persons.Person:
    return await persons.get_by_id(conn, user_id)

@app.get("/api/recipes/parse")
async def parse_recipe_handler(url: str, conn: sqlite3.Connection = Depends(get_db), person = Depends(cookie_person)) -> recipes.Recipe:
    parsed = await recipes.parse_recipe(conn, person, url)
    if not parsed:
        return JSONResponse(status_code=400, content={'message': 'Recipe not found'})
    return parsed

@app.get("/api/recipes/ingredients/parse")
async def parse_ingredients(lines: Annotated[
            List[str], 
            Query(alias="ingredients",
                title="Array of ingredients to parse")], 
        conn: sqlite3.Connection = Depends(get_db)) -> List[ingredients.Ingredient]:
    
    had_links = False
    result = []
    for line in lines:
        ingredient = await ingredients.parse_ingredient_from_link(conn, line)
        if ingredient:
            result.append(ingredient)
            had_links = True
            continue

        ingredient = ingredients.parse_ingredient_from_nlp(line)
        if ingredient:
            result.append(ingredient)
            continue

    if had_links:
        await conn.commit()

    await ingredients.match_existing_products(conn, result)
    return result

class ProductUrl(BaseModel):
    url: str
    tags: List[str] = []

@app.post("/api/products")
async def create_product(url: ProductUrl, conn: sqlite3.Connection = Depends(get_db)) -> products.Product:
    return await products.get_or_create(conn, url.url, url.tags)

async def load_full_recipe(conn: sqlite3.Connection, id: int) -> recipes.Recipe:
    r = await recipes.find_recipe_by_id(conn, id)
    if not r:
        return None

    r.ingredients = []
    async for ingredient in ingredients.find_ingredients_by_recipe_id(conn, id):
        r.ingredients.append(ingredient)
    
    r.created_by = await persons.get_by_id(conn, r.created_by_id)

    return r

@app.get("/api/recipes")
async def get_recipes(q: str | None = None, conn: sqlite3.Connection = Depends(get_db)) -> List[recipes.Recipe]:
    result = []
    if q:
        async for recipe in recipes.find_recipes_by_name(conn, q):
            result.append(recipe)
    else:
        async for recipe in recipes.get_all(conn):
            result.append(recipe)

    for recipe in result:
        recipe.ingredients = []
        async for ingredient in ingredients.find_ingredients_by_recipe_id(conn, recipe.id):
            recipe.ingredients.append(ingredient)
    
    return result

@app.get("/api/recipes/{recipe_id}")
async def get_recipe(recipe_id: int, conn: sqlite3.Connection = Depends(get_db)) -> recipes.Recipe:
    r = await load_full_recipe(conn, recipe_id)
    if not r:
        return JSONResponse(status_code=404, content={'message': 'Recipe not found'})
    
    return r

@app.post('/api/recipes')
async def create_recipe(recipe: recipes.Recipe, conn: sqlite3.Connection = Depends(get_db), user: persons.Person = Depends(cookie_person)) -> recipes.Recipe:
    if not recipe.ingredients:
        return JSONResponse(status_code=400, content={'message': 'Recipe must have at least one ingredient'})
    
    for ingredient in recipe.ingredients:
        if not ingredient.product:
            return JSONResponse(status_code=400, content={'message': 'Ingredient must have a product'})
    
    if recipe.id >= 0:
        await recipes.hide_recipe(conn, recipe.id, user)
        recipe.based_on_recipe = recipe.id
        recipe.id = 0
    
    recipe.created_by_id = user.id
    await recipes.insert_recipe(conn, recipe)
    for ingredient in recipe.ingredients:
        ingredient.recipe_id = recipe.id
        ingredient.product_id = ingredient.product.id
        await ingredients.insert_ingredient(conn, ingredient)

    await conn.commit()
    
    return recipe

@app.delete('/recipes/{recipe_id}')
async def delete_recipe(recipe_id: int, conn: sqlite3.Connection = Depends(get_db), user: persons.Person = Depends(cookie_person)) -> recipes.Recipe:
    recipe = await recipes.find_recipe_by_id(conn, recipe_id)
    if not recipe:
        return JSONResponse(status_code=404, content={'message': 'Recipe not found'})
    
    await recipes.hide_recipe(conn, recipe_id, user)
    await conn.commit()
    return recipe

@app.get("/api/meals/upcoming")
async def get_upcoming_meals(date_from: Annotated[datetime.datetime, Query(alias='from')], to: datetime.datetime, conn: sqlite3.Connection = Depends(get_db)) -> List[meals.Meal]:
    result = []
    async for meal in meals.find_upcoming_meals_by_date_range(conn, date_from, to):
        await meals.load_recipes(conn, meal)
        await meals.load_extra_ingredients(conn, meal)
        await meals.load_participants(conn, meal)
        result.append(meal)

    return result

@app.get("/api/meals/{meal_id}")
async def get_meal(meal_id: int, conn: sqlite3.Connection = Depends(get_db)) -> meals.Meal:
    meal = await meals.find_meal_by_id(conn, meal_id)
    if not meal:
        return JSONResponse(status_code=404, content={'message': 'Meal not found'})

    return meal

def get_duplicates(items: List[meals.Person]) -> set[str]:
    seen : set[int] = set()
    duplicates : set[str] = set()
    for item in items:
        if item.id in seen:
            duplicates.add(item.name)
        seen.add(item.id)
    return duplicates

def validate_meal(meal : meals.Meal) -> JSONResponse | None:
    if not meal.chefs:
        return JSONResponse(status_code=400, content={'message': 'Meal must have at least one chef'})
    
    if not meal.cleanup:
        return JSONResponse(status_code=400, content={'message': 'Meal must have at least one cleanup person'})
    
    if not meal.consumers:
        return JSONResponse(status_code=400, content={'message': 'Meal must have at least one consumer'})
    
    if len(meal.recipes) == 0 and len(meal.extra_ingredients) == 0:
        return JSONResponse(status_code=400, content={'message': 'Meal must have at least one recipe or ingredient'})
    
    duplicates = get_duplicates(meal.chefs)
    if duplicates:
        return JSONResponse(status_code=400, content={'message': f'Duplicate chef: {", ".join(duplicates)}'})
    
    duplicates = get_duplicates(meal.cleanup)
    if duplicates:
        return JSONResponse(status_code=400, content={'message': f'Duplicate cleanup person: {", ".join(duplicates)}'})
    
    duplicates = get_duplicates(meal.consumers)
    if duplicates:
        return JSONResponse(status_code=400, content={'message': f'Duplicate consumer: {", ".join(duplicates)}'})

    zero_servings = [r for r in meal.recipes if r.servings == 0]
    if zero_servings:
        return JSONResponse(status_code=400, content={'message': 'Recipe servings must be greater than 0'})
    
    return None

@app.post("/api/meals")
async def create_meal(meal: meals.Meal, conn: sqlite3.Connection = Depends(get_db)) -> meals.Meal:
    validation_response = validate_meal(meal)
    if validation_response:
        return validation_response

    await meals.insert_meal(conn, meal)
    await conn.commit()
    return meal

@app.put("/api/meals/{meal_id}")
async def update_meal(meal_id: int, meal: meals.Meal, conn: sqlite3.Connection = Depends(get_db)) -> meals.Meal:
    if meal.id != meal_id:
        return JSONResponse(status_code=400, content={'message': 'Meal ID in URL does not match meal ID in body'})
    
    existing = await meals.find_meal_by_id(conn, meal_id)
    if not existing:
        return JSONResponse(status_code=404, content={'message': 'Meal not found'})
    
    validation_response = validate_meal(meal)
    if validation_response:
        return validation_response

    await meals.update_meal(conn, meal)
    await conn.commit()

    return await get_meal(meal_id, conn)

@app.post("/api/meals/{meal_id}/consumed")
async def mark_consumed(meal_id: int, consumed_date: Optional[datetime.datetime] = None, conn: sqlite3.Connection = Depends(get_db), person: persons.Person = Depends(cookie_person)) -> meals.Meal:
    meal = await meals.find_meal_by_id(conn, meal_id)
    if not meal:
        return JSONResponse(status_code=404, content={'message': 'Meal not found'})

    await meals.mark_consumed(conn, meal, consumed_date or datetime.datetime.now())
    await conn.commit()
    return meal

@app.delete("/api/meals/{meal_id}")
async def delete_meal(meal_id: int, conn: sqlite3.Connection = Depends(get_db)) -> meals.Meal:
    meal = await meals.find_meal_by_id(conn, meal_id)
    if not meal:
        return JSONResponse(status_code=404, content={'message': 'Meal not found'})

    await meals.delete_meal(conn, meal.id)
    await conn.commit()
    return meal

@app.get("/api/shopping/{list_id}")
async def get_shopping_list(list_id: Union[int, str], conn: sqlite3.Connection = Depends(get_db)) -> shopping.ShoppingList:
    if list_id.lower() == 'current':
        return await shopping.current_shopping_list(conn)
    
    try:
        list_id = int(list_id)
    except ValueError:
        return JSONResponse(status_code=400, content={'message': 'Invalid shopping list ID'})
        
    return await shopping.load_shopping_list(conn, list_id)

@app.post("/api/shopping/current/purchased")
async def mark_purchased(conn: sqlite3.Connection = Depends(get_db), person: persons.Person = Depends(cookie_person)) -> shopping.ShoppingList:
    response = await shopping.mark_purchased(conn)

    # Its easier to make the next shopping list now, while we know calling it requires commit()
    await shopping.current_shopping_list(conn)
    await conn.commit()
    return response

class FoundResult(BaseModel):
    created: List[shopping.ShoppingListResult] = []
    removed: List[shopping.ShoppingListResult] = []

@app.post("/api/shopping/current/found")
async def mark_shopping_list(ingredients: List[ingredients.Ingredient], conn: sqlite3.Connection = Depends(get_db)) -> FoundResult:
    now = datetime.datetime.now()
    result = FoundResult()
    for ingredient in ingredients:
        existing, created = await shopping.mark_found(conn, ingredient, now)
        result.created.append(created)

        if existing:
            result.removed.append(existing)

    await conn.commit()
    return result

@app.delete("/api/shopping/current/found/{product_id}")
async def unmark_shopping_list(product_id: int, conn: sqlite3.Connection = Depends(get_db)) -> List[shopping.ShoppingListResult]:
    response = await shopping.unmark_found(conn, product_id)
    await conn.commit()
    return response

@app.get("/api/shopping/current/me/ingredients")
async def get_my_shopping_list(conn: sqlite3.Connection = Depends(get_db), person: persons.Person = Depends(cookie_person)) -> List[shopping.ShoppingListRequest]:
    current = await shopping.current_shopping_list(conn)
    return [r async for r in shopping.get_persons_requests(conn, current, person) if r.ingredient]

@app.post("/api/shopping/current/me/ingredients")
async def sync_my_shopping_list(requests: List[ingredients.Ingredient], conn: sqlite3.Connection = Depends(get_db), person: persons.Person = Depends(cookie_person)) -> List[shopping.ShoppingListRequest]:
    current = await shopping.current_shopping_list(conn)
    result = [r async for r in shopping.sync_persons_requested_ingredients(conn, current, person, requests) if r.ingredient]
    await conn.commit()
    return result

class MealIdWrapper(BaseModel):
    meal_id: int

@app.post("/api/shopping/current/meals/me")
async def request_meal(r: MealIdWrapper, conn: sqlite3.Connection = Depends(get_db), person: persons.Person = Depends(cookie_person)) -> shopping.ShoppingListRequest:
    current = await shopping.current_shopping_list(conn)
    meal = await meals.find_meal_by_id(conn, r.meal_id)
    if not meal:
        return JSONResponse(status_code=404, content={'message': 'Meal not found'})
    
    response = await shopping.request_meal(conn, current, person, meal)
    await conn.commit()
    return response

@app.delete("/api/shopping/current/meals/{meal_id}")
async def unrequest_meal(meal_id: int, conn: sqlite3.Connection = Depends(get_db), person: persons.Person = Depends(cookie_person)) -> dict:
    current = await shopping.current_shopping_list(conn)
    meal = await meals.find_meal_by_id(conn, meal_id)
    if not meal:
        return JSONResponse(status_code=404, content={'message': 'Meal not found'})

    await shopping.delete_requests(conn, current, meal)
    await conn.commit()
    return {}

@app.get("/api/persons")
async def get_persons(q: str = None, conn: sqlite3.Connection = Depends(get_db)) -> List[meals.Person]:
    query = persons.search_by_name(conn, q) if q else persons.get_all(conn)
    result = []
    async for person in query:
        result.append(person)

    return result

@app.post("/api/persons")
async def create_person(person: persons.Person, conn: sqlite3.Connection = Depends(get_db)) -> persons.Person:
    await persons.insert_person(conn, person)
    await conn.commit()
    return person

class LoginBody(BaseModel):
    username: str

@app.post('/api/auth/login')
async def login(data: LoginBody, conn: sqlite3.Connection = Depends(get_db)) -> persons.Person:
    person = await persons.get_by_name(conn, data.username)
    if not person:
        return JSONResponse(status_code=404, content={'message': 'Person not found'})
    
    response = JSONResponse(content=jsonable_encoder(person))
    response.set_cookie(key='user_id', value=str(person.id))
    return response

@app.post('/api/auth/refresh')
async def current_user(user: persons.Person = Depends(cookie_person)) -> persons.Person:
    return user

if os.environ.get('DOOF_PROD', False):
    from fastapi.staticfiles import StaticFiles
    app.mount("/", StaticFiles(directory="./front-dist", html=True), name="front-dist")
else:
    # Proxy the request to the frontend development server
    from starlette.requests import Request
    from starlette.responses import StreamingResponse
    from starlette.background import BackgroundTask

    import httpx

    client = httpx.AsyncClient(base_url="http://localhost:8080/")

    async def _reverse_proxy(request: Request):
        url = httpx.URL(path=request.url.path,
                        query=request.url.query.encode("utf-8"))
        rp_req = client.build_request(request.method, url,
                                    headers=request.headers.raw,
                                    content=request.stream())
        rp_resp = await client.send(rp_req, stream=True)
        return StreamingResponse(
            rp_resp.aiter_raw(),
            status_code=rp_resp.status_code,
            headers=rp_resp.headers,
            background=BackgroundTask(rp_resp.aclose),
        )

    app.add_route("/{path:path}",_reverse_proxy, ["GET", "POST"])