use std::sync::Arc;
use std::time::Duration;

use ab_glyph::FontArc;
use dashmap::DashMap;
use sea_orm::{ConnectionTrait, DatabaseConnection, SqlxSqliteConnector};
use zeroize::Zeroizing;

use openposterdb_api::config::Config;
use openposterdb_api::services::fanart::FanartClient;
use openposterdb_api::services::tmdb::TmdbClient;
use openposterdb_api::{build_app, AppState, FONT_BYTES, MIGRATIONS, SCHEMA_SQL};

pub struct TestAppOptions {
    pub cors_origin: Option<String>,
    pub secure_cookies: bool,
    pub enable_cdn_redirects: bool,
    pub external_cache_only: bool,
    pub cache_dir_override: Option<String>,
    pub free_key_enabled: Option<bool>,
    pub disable_fanart: bool,
}

impl Default for TestAppOptions {
    fn default() -> Self {
        Self {
            cors_origin: None,
            secure_cookies: false,
            enable_cdn_redirects: false,
            external_cache_only: false,
            cache_dir_override: None,
            free_key_enabled: None,
            disable_fanart: false,
        }
    }
}

pub async fn setup_test_app_with_options(opts: TestAppOptions) -> (axum::Router, Arc<AppState>) {
    let cors_origin = opts.cors_origin;
    let secure_cookies = opts.secure_cookies;
    let enable_cdn_redirects = opts.enable_cdn_redirects;
    let external_cache_only = opts.external_cache_only;
    let cache_dir_override = opts.cache_dir_override;
    let free_key_enabled = opts.free_key_enabled;
    let disable_fanart = opts.disable_fanart;
    _setup_test_app(cors_origin, secure_cookies, enable_cdn_redirects, external_cache_only, cache_dir_override, free_key_enabled, disable_fanart).await
}

pub async fn setup_test_app_with_cors(cors_origin: Option<String>) -> (axum::Router, Arc<AppState>) {
    _setup_test_app(cors_origin, false, false, false, None, None, false).await
}

async fn _setup_test_app(cors_origin: Option<String>, secure_cookies: bool, enable_cdn_redirects: bool, external_cache_only: bool, cache_dir_override: Option<String>, free_key_enabled: Option<bool>, disable_fanart: bool) -> (axum::Router, Arc<AppState>) {
    let sqlite_opts = sqlx::sqlite::SqliteConnectOptions::new()
        .filename(":memory:")
        .create_if_missing(true)
        .pragma("foreign_keys", "ON");
    let pool = sqlx::sqlite::SqlitePoolOptions::new()
        .max_connections(1)
        .connect_with(sqlite_opts)
        .await
        .expect("failed to connect to test database");
    let db: DatabaseConnection = SqlxSqliteConnector::from_sqlx_sqlite_pool(pool);

    for sql in SCHEMA_SQL {
        db.execute_unprepared(sql)
            .await
            .expect("failed to create table");
    }
    for (sql, expected_err) in MIGRATIONS {
        match db.execute_unprepared(sql).await {
            Ok(_) => {}
            Err(e) if e.to_string().to_lowercase().contains(expected_err) => {}
            Err(e) => panic!("migration failed: {e}\n  SQL: {sql}"),
        }
    }

    let jwt_secret = Zeroizing::new(vec![0xAB; 32]);
    let http = reqwest::Client::new();
    let font = FontArc::try_from_slice(FONT_BYTES).expect("failed to load font");

    let api_key_cache = moka::future::Cache::builder()
        .max_capacity(100)
        .time_to_live(Duration::from_secs(300))
        .build();
    let image_inflight = moka::future::Cache::builder()
        .max_capacity(100)
        .time_to_live(Duration::from_secs(30))
        .build();
    let id_cache = moka::future::Cache::builder()
        .max_capacity(100)
        .time_to_live(Duration::from_secs(3600))
        .build();
    let ratings_cache = moka::future::Cache::builder()
        .max_capacity(100)
        .time_to_live(Duration::from_secs(1800))
        .build();
    let image_mem_cache = moka::future::Cache::builder()
        .max_capacity(1024 * 1024)
        .time_to_live(Duration::from_secs(3600))
        .build();
    let refresh_locks = moka::sync::Cache::builder()
        .max_capacity(100)
        .time_to_live(Duration::from_secs(300))
        .build();

    let state = Arc::new(AppState {
        config: Config {
            tmdb_api_key: "test".into(),
            omdb_api_key: None,
            cache_dir: cache_dir_override.unwrap_or_else(|| "/tmp/openposterdb-test".into()),
            db_dir: "/tmp/openposterdb-test".into(),
            listen_addr: "127.0.0.1:0".into(),
            ratings_min_stale_secs: 86400,
            ratings_max_age_secs: 31_536_000,
            image_stale_secs: 0,
            image_quality: 85,
            mdblist_api_key: None,
            image_mem_cache_mb: 1,
            static_dir: None,
            cors_origin,
            fanart_api_key: if disable_fanart { None } else { Some("test".into()) },
            trakt_client_id: None,
            enable_cdn_redirects,
            external_cache_only,
            free_key_enabled,
            disable_public_pages: false,
        },
        tmdb: TmdbClient::new("test".into(), http.clone()),
        omdb: None,
        mdblist: None,
        trakt: None,

        font,
        refresh_locks,
        db,
        jwt_secret,
        secure_cookies,
        api_key_cache,
        image_inflight,
        id_cache,
        ratings_cache,
        image_mem_cache,
        pending_last_used: Arc::new(DashMap::new()),
        fanart: if disable_fanart { None } else { Some(FanartClient::new("test".into(), http)) },
        fanart_cache: moka::future::Cache::builder()
            .max_capacity(100)
            .time_to_live(Duration::from_secs(3600))
            .build(),
        fanart_negative: moka::future::Cache::builder()
            .max_capacity(100)
            .time_to_live(Duration::from_secs(3600))
            .build(),
        tmdb_images_cache: moka::future::Cache::builder()
            .max_capacity(100)
            .time_to_live(Duration::from_secs(1800))
            .build(),
        settings_cache: moka::future::Cache::builder()
            .max_capacity(100)
            .time_to_live(Duration::from_secs(300))
            .build(),
        global_settings_cache: moka::future::Cache::builder()
            .max_capacity(1)
            .time_to_live(Duration::from_secs(300))
            .build(),
        preview_cache: moka::future::Cache::builder()
            .max_capacity(500)
            .time_to_live(Duration::from_secs(300))
            .build(),
        free_api_key_cache: moka::future::Cache::builder()
            .max_capacity(1)
            .time_to_live(Duration::from_secs(60))
            .build(),
        render_semaphore: Arc::new(tokio::sync::Semaphore::new(4)),
        cross_id_semaphore: Arc::new(tokio::sync::Semaphore::new(8)),
        settings_hash_registry: moka::future::Cache::builder()
            .max_capacity(100)
            .time_to_live(Duration::from_secs(300))
            .build(),
        available_ratings_cache: moka::future::Cache::builder()
            .max_capacity(1000)
            .time_to_live(Duration::from_secs(300))
            .build(),
    });

    let app = build_app(state.clone());
    (app, state)
}

pub async fn setup_test_app() -> (axum::Router, Arc<AppState>) {
    setup_test_app_with_cors(None).await
}

/// Helper to perform setup and get back an access token.
pub async fn setup_admin(app: &axum::Router) -> String {
    use axum::body::Body;
    use axum::http::{Request, StatusCode};
    use http_body_util::BodyExt;
    use tower::ServiceExt;

    let req = Request::builder()
        .method("POST")
        .uri("/api/auth/setup")
        .header("content-type", "application/json")
        .body(Body::from(
            serde_json::json!({"username": "admin", "password": "testpassword123"}).to_string(),
        ))
        .unwrap();

    let res = app.clone().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);

    let body = res.into_body().collect().await.unwrap().to_bytes();
    let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
    json["token"].as_str().unwrap().to_string()
}

/// Helper: set up admin, create an API key, log in with it, and return the session JWT.
pub async fn setup_api_key_session(app: &axum::Router) -> String {
    use axum::body::Body;
    use axum::http::{Request, StatusCode};
    use http_body_util::BodyExt;
    use tower::ServiceExt;

    let admin_token = setup_admin(app).await;

    // Create an API key
    let req = Request::builder()
        .method("POST")
        .uri("/api/keys")
        .header("content-type", "application/json")
        .header("authorization", format!("Bearer {admin_token}"))
        .body(Body::from(
            serde_json::json!({"name": "preview-test-key"}).to_string(),
        ))
        .unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
    let body = res.into_body().collect().await.unwrap().to_bytes();
    let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
    let raw_key = json["key"].as_str().unwrap().to_string();

    // Log in with the API key
    let req = Request::builder()
        .method("POST")
        .uri("/api/auth/key-login")
        .header("content-type", "application/json")
        .body(Body::from(
            serde_json::json!({"api_key": raw_key}).to_string(),
        ))
        .unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
    let body = res.into_body().collect().await.unwrap().to_bytes();
    let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
    json["token"].as_str().unwrap().to_string()
}

/// Extract Set-Cookie header value from a response.
pub fn extract_set_cookie(headers: &axum::http::HeaderMap) -> Option<String> {
    headers
        .get(axum::http::header::SET_COOKIE)
        .and_then(|v| v.to_str().ok())
        .map(|s| s.to_string())
}

/// Extract the refresh_token value from a Set-Cookie header.
pub fn extract_refresh_token(set_cookie: &str) -> Option<String> {
    set_cookie
        .split(';')
        .next()
        .and_then(|s| s.strip_prefix("refresh_token="))
        .map(|s| s.to_string())
}