// file: kb_lib/src/db/dtos/program_instruction_diagnostic.rs

//! Program instruction diagnostic DTO.

/// Diagnostic row for instructions of one Solana program.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ProgramInstructionDiagnosticDto {
    /// Parent transaction id.
    pub transaction_id: i64,
    /// Transaction signature.
    pub signature: std::string::String,
    /// Optional Solana slot.
    pub slot: std::option::Option<u64>,
    /// Internal instruction id.
    pub instruction_id: i64,
    /// Optional parent instruction id.
    pub parent_instruction_id: std::option::Option<i64>,
    /// Outer instruction index.
    pub instruction_index: u32,
    /// Optional inner instruction index.
    pub inner_instruction_index: std::option::Option<u32>,
    /// Program id.
    pub program_id: std::option::Option<std::string::String>,
    /// Optional program name.
    pub program_name: std::option::Option<std::string::String>,
    /// Optional stack height.
    pub stack_height: std::option::Option<u32>,
    /// Number of accounts in `accounts_json`.
    pub accounts_count: u64,
    /// First account, when present.
    pub account_0: std::option::Option<std::string::String>,
    /// Second account, when present.
    pub account_1: std::option::Option<std::string::String>,
    /// Third account, when present.
    pub account_2: std::option::Option<std::string::String>,
    /// Fourth account, when present.
    pub account_3: std::option::Option<std::string::String>,
    /// Last account, when present.
    pub last_account: std::option::Option<std::string::String>,
    /// Optional parsed instruction type.
    pub parsed_type: std::option::Option<std::string::String>,
    /// True when `data_json` exists.
    pub has_data_json: bool,
    /// True when `parsed_json` exists.
    pub has_parsed_json: bool,
    /// Short data JSON preview.
    pub data_json_preview: std::option::Option<std::string::String>,
    /// Short parsed JSON preview.
    pub parsed_json_preview: std::option::Option<std::string::String>,
    /// JSON array of useful log hints.
    pub log_hints_json: std::string::String,
}

impl TryFrom<crate::ProgramInstructionDiagnosticEntity> for ProgramInstructionDiagnosticDto {
    type Error = crate::Error;

    fn try_from(entity: crate::ProgramInstructionDiagnosticEntity) -> Result<Self, Self::Error> {
        let slot = match entity.slot {
            Some(slot) => match u64::try_from(slot) {
                Ok(slot) => Some(slot),
                Err(error) => {
                    return Err(crate::Error::Db(format!(
                        "cannot convert program instruction diagnostic slot '{}' to u64: {}",
                        slot, error
                    )));
                },
            },
            None => None,
        };
        let instruction_index = match u32::try_from(entity.instruction_index) {
            Ok(instruction_index) => instruction_index,
            Err(error) => {
                return Err(crate::Error::Db(format!(
                    "cannot convert program instruction diagnostic instruction_index '{}' to u32: {}",
                    entity.instruction_index, error
                )));
            },
        };
        let inner_instruction_index = match entity.inner_instruction_index {
            Some(inner_instruction_index) => match u32::try_from(inner_instruction_index) {
                Ok(inner_instruction_index) => Some(inner_instruction_index),
                Err(error) => {
                    return Err(crate::Error::Db(format!(
                        "cannot convert program instruction diagnostic inner_instruction_index '{}' to u32: {}",
                        inner_instruction_index, error
                    )));
                },
            },
            None => None,
        };
        let stack_height = match entity.stack_height {
            Some(stack_height) => match u32::try_from(stack_height) {
                Ok(stack_height) => Some(stack_height),
                Err(error) => {
                    return Err(crate::Error::Db(format!(
                        "cannot convert program instruction diagnostic stack_height '{}' to u32: {}",
                        stack_height, error
                    )));
                },
            },
            None => None,
        };
        let accounts = parse_accounts_json(entity.accounts_json.as_str());
        let accounts_count = match u64::try_from(accounts.len()) {
            Ok(accounts_count) => accounts_count,
            Err(error) => {
                return Err(crate::Error::Db(format!(
                    "cannot convert accounts count to u64: {}",
                    error
                )));
            },
        };
        let account_0 = account_at(&accounts, 0);
        let account_1 = account_at(&accounts, 1);
        let account_2 = account_at(&accounts, 2);
        let account_3 = account_at(&accounts, 3);
        let last_account = match accounts.last() {
            Some(last_account) => Some(last_account.clone()),
            None => None,
        };
        let log_hints =
            collect_log_hints(entity.meta_json.as_deref(), entity.transaction_json.as_str());
        let log_hints_json_result = serde_json::to_string(&log_hints);
        let log_hints_json = match log_hints_json_result {
            Ok(log_hints_json) => log_hints_json,
            Err(error) => {
                return Err(crate::Error::Json(format!(
                    "cannot serialize program instruction log hints: {}",
                    error
                )));
            },
        };
        return Ok(Self {
            transaction_id: entity.transaction_id,
            signature: entity.signature,
            slot,
            instruction_id: entity.instruction_id,
            parent_instruction_id: entity.parent_instruction_id,
            instruction_index,
            inner_instruction_index,
            program_id: entity.program_id,
            program_name: entity.program_name,
            stack_height,
            accounts_count,
            account_0,
            account_1,
            account_2,
            account_3,
            last_account,
            parsed_type: entity.parsed_type,
            has_data_json: entity.data_json.is_some(),
            has_parsed_json: entity.parsed_json.is_some(),
            data_json_preview: preview_text(entity.data_json.as_deref(), 600),
            parsed_json_preview: preview_text(entity.parsed_json.as_deref(), 1200),
            log_hints_json,
        });
    }
}

fn account_at(
    accounts: &[std::string::String],
    index: usize,
) -> std::option::Option<std::string::String> {
    match accounts.get(index) {
        Some(account) => return Some(account.clone()),
        None => return None,
    }
}

fn preview_text(
    text: std::option::Option<&str>,
    max_len: usize,
) -> std::option::Option<std::string::String> {
    let text = match text {
        Some(text) => text,
        None => return None,
    };
    if text.len() <= max_len {
        return Some(text.to_string());
    }
    let mut preview = text.chars().take(max_len).collect::<std::string::String>();
    preview.push_str("...");
    return Some(preview);
}

fn parse_accounts_json(accounts_json: &str) -> std::vec::Vec<std::string::String> {
    let parsed_result = serde_json::from_str::<serde_json::Value>(accounts_json);
    let parsed = match parsed_result {
        Ok(parsed) => parsed,
        Err(_) => return std::vec::Vec::new(),
    };
    let array = match parsed.as_array() {
        Some(array) => array,
        None => return std::vec::Vec::new(),
    };
    let mut accounts = std::vec::Vec::new();
    for item in array {
        if let Some(text) = item.as_str() {
            accounts.push(text.to_string());
            continue;
        }
        if let Some(pubkey) = item.get("pubkey").and_then(|value| return value.as_str()) {
            accounts.push(pubkey.to_string());
        }
    }
    return accounts;
}

fn collect_log_hints(
    meta_json: std::option::Option<&str>,
    transaction_json: &str,
) -> std::vec::Vec<std::string::String> {
    let mut hints = std::vec::Vec::new();
    if let Some(meta_json) = meta_json {
        collect_log_hints_from_json_text(meta_json, &mut hints);
    }
    collect_log_hints_from_json_text(transaction_json, &mut hints);
    hints.sort();
    hints.dedup();
    return hints;
}

fn collect_log_hints_from_json_text(
    json_text: &str,
    hints: &mut std::vec::Vec<std::string::String>,
) {
    let value_result = serde_json::from_str::<serde_json::Value>(json_text);
    let value = match value_result {
        Ok(value) => value,
        Err(_) => return,
    };
    collect_log_hints_from_value(&value, hints);
}

fn collect_log_hints_from_value(
    value: &serde_json::Value,
    hints: &mut std::vec::Vec<std::string::String>,
) {
    match value {
        serde_json::Value::String(text) => {
            let normalized = text.to_ascii_lowercase();
            if normalized.contains("instruction:")
                || normalized.contains("meteora")
                || normalized.contains("dlmm")
                || normalized.contains("lb")
                || normalized.contains("swap")
                || normalized.contains("bin")
            {
                hints.push(text.clone());
            }
        },
        serde_json::Value::Array(values) => {
            for nested in values {
                collect_log_hints_from_value(nested, hints);
            }
        },
        serde_json::Value::Object(object) => {
            for nested in object.values() {
                collect_log_hints_from_value(nested, hints);
            }
        },
        _ => {},
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn accounts_json_extracts_string_accounts() {
        let accounts = super::parse_accounts_json(
            serde_json::json!(["A111", "B222", "C333"]).to_string().as_str(),
        );
        assert_eq!(accounts.len(), 3);
        assert_eq!(accounts[0], "A111");
        assert_eq!(accounts[1], "B222");
        assert_eq!(accounts[2], "C333");
    }

    #[test]
    fn log_hints_are_extracted_from_nested_json() {
        let mut hints = std::vec::Vec::new();
        super::collect_log_hints_from_json_text(
            serde_json::json!({
                "meta": {
                    "logMessages": [
                        "Program log: Instruction: Swap",
                        "irrelevant"
                    ]
                }
            })
            .to_string()
            .as_str(),
            &mut hints,
        );
        assert_eq!(hints.len(), 1);
        assert_eq!(hints[0], "Program log: Instruction: Swap");
    }
}