use axum::{
    Json, debug_handler,
    extract::{Query, State},
    http::StatusCode,
};
use serde::{Deserialize, Serialize};
use tracing::{error, info};

use crate::{
    instance::Instance,
    video::{Video, VideoError},
};

#[derive(Debug, Deserialize)]
pub struct ListEntriesQuery {
    page: Option<usize>,
}

#[derive(Debug, Serialize)]
pub struct ListEntriesResponse {
    videos: Vec<Video>,
    page: usize,
    per_page: usize,
    total: usize,
    pages: usize,
}

/// Retrieve video list as JSON (paged)
#[debug_handler]
pub async fn list_entries(
    State(state): State<Instance>,
    Query(query): Query<ListEntriesQuery>,
) -> Result<Json<ListEntriesResponse>, StatusCode> {
    let Ok(videos) = state.fetch_videos().await else {
        error!("Could not fetch videos from database!");
        return Err(StatusCode::INTERNAL_SERVER_ERROR);
    };

    let page = query.page.unwrap_or(1).max(1);
    let per_page = state.config.videos_per_page;
    let total = videos.len();
    let pages = (total + per_page - 1).div_ceil(per_page);

    let start = per_page * (page - 1);
    let end = (start + per_page).min(total);

    let videos = if start < total {
        videos[start..end].to_vec()
    } else {
        vec![]
    };

    Ok(Json(ListEntriesResponse {
        videos,
        page,
        per_page,
        total,
        pages,
    }))
}

#[derive(Debug, Deserialize)]
pub struct UploadVideoQuery {
    url: String,
    cookie: Option<String>,
}

/// Upload a video to the database
pub async fn upload_video(
    State(state): State<Instance>,
    Query(query): Query<UploadVideoQuery>,
) -> StatusCode {
    let Ok(videos) = state.fetch_videos().await else {
        error!("Could not fetch videos from database!");
        return StatusCode::INTERNAL_SERVER_ERROR;
    };

    let new_video = Video::from_url(&query.url, videos.len(), query.cookie.as_deref())
        .await
        .map_err(|e| match e {
            VideoError::InvalidUrl | VideoError::UrlParse(_) => StatusCode::BAD_REQUEST,
            _ => StatusCode::INTERNAL_SERVER_ERROR,
        });

    match new_video {
        Ok(video) => {
            match sqlx::query!(
                r#"
                INSERT INTO video (
                    id, url, youtube_id, title, description, author, author_id, author_url,
                    views, upload_date, likes, dislikes, file_name, file_size, sha256, thumbnail
                )
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                "#,
                video.id,
                video.url,
                video.youtube_id,
                video.title,
                video.description,
                video.author,
                video.author_id,
                video.author_url,
                video.views,
                video.upload_date,
                video.likes,
                video.dislikes,
                video.file_name,
                video.file_size,
                video.sha256,
                video.thumbnail,
            )
            .execute(&state.pool)
            .await
            {
                Ok(result) => {
                    info!("Inserted video to database successfully! {result:?}");
                    StatusCode::OK
                }
                Err(e) => {
                    error!("Error inserting video to database: {e:?}");
                    StatusCode::INTERNAL_SERVER_ERROR
                }
            }
        }
        Err(status) => status,
    }
}