use anyhow::{
    Context,
    Result,
};
use chrono::{
    Utc,
};
use clap::{
    Parser,
};
use flake_tracker::{
    flake::{
        FlakeLocksNodeInputs,
        FlakeMetadata,
        FlakeUri,
    },
};
use sqlx::{
    sqlite::SqlitePoolOptions,
};
use std::process::Command;

#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Cli {
    flake_uri: String,
}

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    let scan_time = Utc::now().timestamp();

    let db = SqlitePoolOptions::new().connect("sqlite://flake-tracker.db").await?;

    let flake_metadata_raw = Command::new("nix")
        .arg("flake")
        .arg("metadata")
        .arg("--json")
        .arg(cli.flake_uri)
        .output()
        .context("Failed to fetch flake metadata")?;

    let flake_metadata: FlakeMetadata = serde_json::from_slice(&flake_metadata_raw.stdout)
        .context("Failed to parse flake metadata")?;

    sqlx::query("INSERT INTO revisions (revision_uri, flake_uri, nix_store_path, nar_hash, last_modified, tracker_last_scanned)
        VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(revision_uri) DO UPDATE SET
            flake_uri=excluded.flake_uri,
            nix_store_path=excluded.nix_store_path,
            nar_hash=excluded.nar_hash,
            last_modified=excluded.last_modified,
            tracker_last_scanned=excluded.tracker_last_scanned
        ")
        .bind(&flake_metadata.locked.flake_uri()?)
        .bind(&flake_metadata.resolved.flake_uri()?)
        .bind(&flake_metadata.path)
        .bind(&flake_metadata.locked.narHash)
        .bind(&flake_metadata.locked.lastModified)
        .bind(&scan_time)
        .execute(&db).await?;

    let locks_root_name = &flake_metadata.locks.root;
    let locks_root_node = flake_metadata.locks.nodes.get(locks_root_name)
        .context("Failed to get locks root node")?;

    for (input_name, locks_input_name) in locks_root_node.inputs.clone().context("No inputs found for flake")? {

        if let FlakeLocksNodeInputs::String(locks_input_name) = locks_input_name {
            let locks_input_node = flake_metadata.locks.nodes.get(&locks_input_name)
                .context("Failed to find lock of input")?;

            sqlx::query("INSERT INTO inputs (revision_uri, input_name, locked_revision_uri, locked_flake_uri, locked_nar_hash, last_modified)
                VALUES (?, ?, ?, ?, ?, ?)
                ON CONFLICT(revision_uri, input_name) DO UPDATE SET
                    locked_revision_uri=excluded.locked_revision_uri,
                    locked_flake_uri=excluded.locked_flake_uri,
                    locked_nar_hash=excluded.locked_nar_hash,
                    last_modified=excluded.last_modified
                ")
                .bind(flake_metadata.locked.flake_uri()?)
                .bind(input_name)
                .bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.flake_uri()?)
                .bind(locks_input_node.original.clone().context("Unexpected missing lock")?.flake_uri()?)
                .bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.narHash)
                .bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.lastModified)
                .execute(&db).await?;

            sqlx::query("INSERT INTO revisions (revision_uri, flake_uri)
                VALUES (?, ?)
                ON CONFLICT(revision_uri) DO NOTHING
                ")
                .bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.flake_uri()?)
                .bind(locks_input_node.original.clone().context("Unexpected missing lock")?.flake_uri()?)
                .execute(&db).await?;
        }
    }

    Ok(())
}