use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, ActiveValue::Set};
use crate::entity::{available_ratings, cleanup_state, image_meta};
use crate::AppState;

const CLEANUP_INTERVAL_SECS: i64 = 7 * 24 * 3600;

fn now_secs() -> i64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64
}

/// Checks whether a cleanup run is overdue (last run more than 7 days ago,
/// or never run) and if so, runs it. Called periodically from a background
/// task. Reading a persisted timestamp (rather than an in-memory one) means
/// a run that was missed while the container was asleep/restarted still
/// happens promptly on the next check after waking, instead of being
/// silently skipped.
pub async fn run_if_due(state: &AppState) {
    let now = now_secs();
    let last_run = match cleanup_state::Entity::find_by_id(true).one(&state.db).await {
        Ok(Some(row)) => row.last_run,
        Ok(None) => None,
        Err(e) => {
            tracing::warn!(error = %e, "failed to read cleanup_state, skipping this check");
            return;
        }
    };
    let due = match last_run {
        Some(t) => now - t >= CLEANUP_INTERVAL_SECS,
        None => true,
    };
    if !due {
        return;
    }
    run_cleanup(state, false).await;
    let model = cleanup_state::ActiveModel {
        id: Set(true),
        last_run: Set(Some(now)),
    };
    if let Err(e) = cleanup_state::Entity::insert(model)
        .on_conflict(
            sea_orm::sea_query::OnConflict::column(cleanup_state::Column::Id)
                .update_columns([cleanup_state::Column::LastRun])
                .to_owned(),
        )
        .exec(&state.db)
        .await
    {
        tracing::warn!(error = %e, "failed to update cleanup_state.last_run");
    }
}

/// Deletes image_meta and available_ratings rows older than 7 days, and
/// purges the corresponding Cloudflare Cache-Tags. Lazy: does not
/// re-render anything, the next real request for a purged title is simply
/// treated as a cache miss. In dry_run mode, only logs what would be
/// deleted.
pub async fn run_cleanup(state: &AppState, dry_run: bool) {
    let cutoff = now_secs() - CLEANUP_INTERVAL_SECS;

    let expired_images = match image_meta::Entity::find()
        .filter(image_meta::Column::UpdatedAt.lt(cutoff))
        .all(&state.db)
        .await
    {
        Ok(rows) => rows,
        Err(e) => {
            tracing::warn!(error = %e, "cleanup: failed to query expired image_meta rows");
            return;
        }
    };

    if expired_images.is_empty() {
        tracing::info!("cleanup: no expired image_meta rows found");
        return;
    }

    tracing::info!(count = expired_images.len(), dry_run, "cleanup: expired image_meta rows found");

    if dry_run {
        for row in &expired_images {
            tracing::info!(cache_key = %row.cache_key, "cleanup (dry run): would delete");
        }
        return;
    }

    // Cloudflare tags are keyed "id:{id_type}:{id_value}" derived from the
    // cache_key prefix (before the settings suffix), matching the format
    // purge_cloudflare_tags() already expects.
    let prefixes: Vec<String> = expired_images
        .iter()
        .filter_map(|row| {
            let parts: Vec<&str> = row.cache_key.splitn(2, '/').collect();
            if parts.len() == 2 {
                let id_part = parts[1].split(|c| c == '@' || c == '.').next().unwrap_or(parts[1]);
                Some(format!("{}/{}", parts[0], id_part))
            } else {
                None
            }
        })
        .collect();

    match crate::services::stremio_account::purge_cloudflare_tags(&state.http, &prefixes).await {
        Ok(n) => tracing::info!(purged = n, "cleanup: Cloudflare tags purged"),
        Err(e) => tracing::warn!(error = %e, "cleanup: Cloudflare purge failed, continuing with Postgres delete anyway"),
    }

    let cache_keys: Vec<String> = expired_images.iter().map(|r| r.cache_key.clone()).collect();
    match image_meta::Entity::delete_many()
        .filter(image_meta::Column::CacheKey.is_in(cache_keys))
        .exec(&state.db)
        .await
    {
        Ok(res) => tracing::info!(deleted = res.rows_affected, "cleanup: image_meta rows deleted"),
        Err(e) => tracing::warn!(error = %e, "cleanup: failed to delete expired image_meta rows"),
    }

    match available_ratings::Entity::delete_many()
        .filter(available_ratings::Column::UpdatedAt.lt(cutoff))
        .exec(&state.db)
        .await
    {
        Ok(res) => tracing::info!(deleted = res.rows_affected, "cleanup: available_ratings rows deleted"),
        Err(e) => tracing::warn!(error = %e, "cleanup: failed to delete expired available_ratings rows"),
    }
}