// Copyright (C) 2024 Riften Labs AS
//
// This software is licensed under the GNU Affero General Public License (AGPL), version 3.0 or later.
// A copy of the license can be found in the LICENSE file or at https://www.gnu.org/licenses/agpl-3.0.html

use std::collections::HashMap;

use anyhow::Result;
use log::info;
use rayon::iter::{IntoParallelIterator, ParallelIterator};
use rocket::{get, http::Status, response::status::Custom, serde::json::Json, State};
use rusqlite::Connection;
use serde_json::{json, Value};

use crate::db::{
    cauldron::poolvisitor::{
        db_visit_pool_entries, OptionalFields, OptionalPoolFields, PoolFilters, PoolVisitor,
    },
    DB,
};

#[derive(Default)]
struct TvlByTokenVisitor {
    tvl: HashMap<String, (u64, u64)>,
}

impl PoolVisitor for TvlByTokenVisitor {
    fn optional_fields_wanted(&self) -> u64 {
        OptionalPoolFields::TokenId as u64
    }

    fn visit(&mut self, sats: u64, tokens: u64, optional_fields: OptionalFields) -> Result<bool> {
        let token_id = optional_fields.token_id.unwrap();

        let entry = self.tvl.entry(token_id).or_insert((0u64, 0u64));
        entry.0 += sats;
        entry.1 += tokens;

        Ok(true)
    }
}

#[derive(Default)]
struct TvlVisitor {
    sats: u64,
    tokens: u64,
}

impl PoolVisitor for TvlVisitor {
    fn optional_fields_wanted(&self) -> u64 {
        0
    }

    fn visit(&mut self, sats: u64, tokens: u64, _optional_fields: OptionalFields) -> Result<bool> {
        self.sats += sats;
        self.tokens += tokens;

        Ok(true)
    }
}

#[derive(Default)]
struct TvlSatsOnlyVisitor {
    sats: u64,
}

impl PoolVisitor for TvlSatsOnlyVisitor {
    fn optional_fields_wanted(&self) -> u64 {
        0
    }

    fn visit(&mut self, sats: u64, _tokens: u64, _optional_fields: OptionalFields) -> Result<bool> {
        self.sats += sats;

        Ok(true)
    }
}

/// Fetch TVL for all tokens by token id (deprecated)
pub fn deprecated_get_all_token_tvl(
    connection: &Connection,
    max_timestamp: usize,
) -> Result<HashMap<String, (u64, u64)>> {
    info!("kom hit 2");

    let mut visitor = TvlByTokenVisitor::default();
    db_visit_pool_entries(
        connection,
        &mut visitor,
        PoolFilters {
            timestamp_less_than: Some(max_timestamp as u64),
            token_id: None,
            owner: None,
        },
    )?;

    Ok(visitor.tvl)
}

/// Fetch sats side of TVL for all tokens
pub fn get_total_sats_tvl(connection: &Connection, max_timestamp: Option<usize>) -> Result<u64> {
    let mut visitor = TvlSatsOnlyVisitor::default();
    db_visit_pool_entries(
        connection,
        &mut visitor,
        PoolFilters {
            timestamp_less_than: max_timestamp.map(|t| t as u64),
            token_id: None,
            owner: None,
        },
    )?;

    Ok(visitor.sats)
}

/// Get TVL for a single token
pub fn get_token_tvl(
    connection: &Connection,
    max_timestamp: Option<usize>,
    token_id: &str,
) -> Result<(u64, u64)> {
    let mut visitor = TvlVisitor::default();
    db_visit_pool_entries(
        connection,
        &mut visitor,
        PoolFilters {
            timestamp_less_than: max_timestamp.map(|t| t as u64),
            token_id: Some(token_id.to_string()),
            owner: None,
        },
    )?;

    Ok((visitor.sats, visitor.tokens))
}

// Deprecated; use valuelocked with optional parameters
// used by defilama; fix adapter first
#[get("/tvl/<time>")]
pub fn deprecated_tvl(time: usize, conn: &State<DB>) -> Result<Json<Vec<Value>>, Custom<String>> {
    let db = conn
        .cauldron_r
        .get()
        .map_err(|e| Custom(Status::InternalServerError, format!("Error: {e}")))?;

    info!("kom hit");

    let tvl: HashMap<String, (u64, u64)> = deprecated_get_all_token_tvl(&db, time)
        .map_err(|e| Custom(Status::InternalServerError, format!("Error: {e}")))?;

    let result: Vec<Value> = tvl
        .into_par_iter()
        .map(|(token, (sats, token_amount))| {
            json!({
                "token_id": token,
                "satoshis": sats,
                "token_amount": token_amount,
            })
        })
        .collect();

    Ok(Json(result))
}

#[get("/valuelocked?<time>")]
pub fn valuelocked_all(
    time: Option<usize>,
    conn: &State<DB>,
) -> Result<Json<Value>, Custom<String>> {
    let db = conn.cauldron_r.get().map_err(|_| {
        Custom(
            Status::InternalServerError,
            "Failed to get DB connection".into(),
        )
    })?;

    let sats: u64 = get_total_sats_tvl(&db, time)
        .map_err(|e| Custom(Status::InternalServerError, format!("Error: {e}")))?;

    Ok(Json(json!({
        "satoshis": sats
    })))
}

#[get("/valuelocked/<token>?<time>")]
pub fn valuelocked_token(
    token: &str,
    time: Option<usize>,
    conn: &State<DB>,
) -> Result<Json<Value>, Custom<String>> {
    let db = conn.cauldron_r.get().map_err(|_| {
        Custom(
            Status::InternalServerError,
            "Failed to get DB connection".into(),
        )
    })?;

    let (sats, token_amount) = get_token_tvl(&db, time, token)
        .map_err(|e| Custom(Status::InternalServerError, format!("Error: {e}")))?;

    Ok(Json(json!({
        "token_amount": token_amount,
        "satoshis": sats
    })))
}