pub mod digest;

use chrono::serde::ts_seconds_option;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::fmt::{Display, Formatter};

/// MDB version
pub const MDB_VERSION: &str = env!("CARGO_PKG_VERSION");

/// Login API endpoint, POST
pub const USER_LOGIN_URL: &str = "/v1/users/getkey";

/// User logs in with username and password
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct GetAPIKeyRequest {
    pub user: String,
    pub password: String,
}

/// Logout API endpoint, POST
pub const USER_LOGOUT_URL: &str = "/v1/users/clearkey";

/// Response includes the key, if the credentials were correct,
/// and possibly show a message related to errors or warnings.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct GetAPIKeyResponse {
    pub key: Option<String>,
    pub message: Option<String>,
}

/// User's get self information API endpoint, POST
/// User `EmptyAuthenticatingPost` to authenticate
pub const USER_INFO_URL: &str = "/v1/users/info";

/// User gets information about their account
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct GetUserInfoResponse {
    pub id: i32,
    pub username: String,
    pub groups: Vec<String>,
    pub sources: Vec<String>,
    pub is_admin: bool,
}

/// Server information, request is empty, GET
pub const SERVER_INFO: &str = "/v1/server/info";

/// Information about the server
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
pub struct ServerInfo {
    pub os_name: String,
    pub os_version: String,
    pub memory_used: String,
    pub mdb_version: String,
    pub db_version: String,
    pub db_size: String,
    pub num_samples: u64,
    pub num_users: u32,
    pub uptime: String,
}

/// File types supported by MalwareDB, request is empty, GET
pub const SUPPORTED_FILE_TYPES: &str = "/v1/server/types";

/// One record of supported file types
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SupportedFileType {
    pub name: String,
    pub magic: Vec<String>,
    pub is_executable: bool,
    pub description: Option<String>,
}

/// All of the supported types, the response
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SupportedFileTypes {
    pub types: Vec<SupportedFileType>,
    pub message: Option<String>,
}

/// Endpoint for the sources, per-user, POST
pub const GET_SOURCES: &str = "/v1/sources/list";

/// Generic POST for authenticating with the API key
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct EmptyAuthenticatingPost {
    pub key: String,
}

/// Source record
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SourceInfo {
    pub id: u64,
    pub name: String,
    pub description: Option<String>,
    pub url: Option<String>,
    #[serde(with = "ts_seconds_option")]
    pub first_acquisition: Option<DateTime<Utc>>,
}

/// Sources response
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Sources {
    pub sources: Vec<SourceInfo>,
    pub message: Option<String>,
}

/// API endpoint for uploading a sample, POST
pub const UPLOAD_SAMPLE: &str = "/v1/samples/upload";

/// New file sample being sent to MalwareDB
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct NewSample {
    /// The original file name, might not be known
    pub file_name: String,

    /// User's API key, must be validated before anything else
    pub key: String,

    /// ID of the source for this sample
    pub source_id: u32,

    /// Base64 encoding of the binary file
    pub file_contents_b64: String,

    /// SHA-256 of the sample being sent, for server-side validation
    pub sha256: String,
}

/// API endpoint for downloading a sample, POST
/// Response is raw bytes of the file, or HTTP 404 if not found
pub const DOWNLOAD_SAMPLE: &str = "/v1/samples/download";

/// API endpoint for downloading a sample as a CaRT file, POST
/// Response is the file encoded in a CaRT container file, or HTTP 404 if not found
pub const DOWNLOAD_SAMPLE_CART: &str = "/v1/samples/download/cart";

/// Requesting a sample from MalwareDB
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct DownloadSampleRequest {
    /// User's API key, must be validated before anything else
    pub key: String,

    /// The hash of the requested sample
    pub hash: digest::HashType,
}

/// API endpoint to get a report for a given sample, use `DownloadSampleRequest` as the request structure
pub const SAMPLE_REPORT: &str = "/v1/samples/report";

// TODO: Add sections for parsed fields for documents, executables
/// All the data for a sample known to MalwareDB
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
pub struct Report {
    pub md5: String,
    pub sha1: String,
    pub sha256: String,
    pub sha384: String,
    pub sha512: String,
    pub lzjd: Option<String>,
    pub tlsh: Option<String>,
    pub ssdeep: Option<String>,
    pub sdhash: Option<String>,
    pub humanhash: Option<String>,
    pub filecommand: Option<String>,
    pub bytes: u32,
    pub size: String,
    pub entropy: f32,
}

impl Display for Report {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "Size: {} bytes, or {}", self.bytes, self.size)?;
        writeln!(f, "Entropy: {}", self.entropy)?;
        if let Some(filecmd) = &self.filecommand {
            writeln!(f, "File command: {filecmd}")?;
        }
        writeln!(f, "MD5: {}", self.md5)?;
        writeln!(f, "SHA-1: {}", self.sha1)?;
        writeln!(f, "SHA256: {}", self.sha256)
    }
}

/// API endpoint for finding samples which are similar to specific file, POST
pub const SIMILAR_SAMPLES: &str = "/v1/samples/similar";

/// The hash by which a sample is identified
#[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Serialize)]
#[non_exhaustive]
pub enum SimilarityHashType {
    SSDeep,
    SDHash,
    LZJD,
    TLSH,
    PEHash,
    ImportHash,
    FuzzyImportHash,
}

impl SimilarityHashType {
    /// For a similarity hash type, return:
    /// * The database table & field which stores the hash
    /// * If applicable, the similarity hash function (Postgres extension) which calculates the similarity
    pub fn get_table_field_simfunc(&self) -> (&'static str, Option<&'static str>) {
        match self {
            SimilarityHashType::SSDeep => ("file.ssdeep", Some("fuzzy_hash_compare")),
            SimilarityHashType::SDHash => ("file.sdhash", Some("sdhash_compare")),
            SimilarityHashType::LZJD => ("file.lzjd", Some("lzjd_compare")),
            SimilarityHashType::TLSH => ("file.tlsh", Some("tlsh_compare")),
            SimilarityHashType::PEHash => ("executable.pehash", None),
            SimilarityHashType::ImportHash => ("executable.importhash", None),
            SimilarityHashType::FuzzyImportHash => {
                ("executable.importhashfuzzy", Some("fuzzy_hash_compare"))
            }
        }
    }
}
/*
impl TryFrom<String> for SimilarityHashType {
    type Error = &'static str;

    fn try_from(value: String) -> Result<Self, Self::Error> {
        let lower = value.to_ascii_lowercase();

        if lower == "lzjd" {
            return Ok(SimilarityHashType::LZJD);
        }
        if lower == "ssdeep" {
            return Ok(SimilarityHashType::SSDeep);
        }
        if lower == "sdhash" {
            return Ok(SimilarityHashType::SDHash);
        }
        if lower == "tlsh" {
            return Ok(SimilarityHashType::TLSH);
        }
        if lower == "pehash" {
            return Ok(SimilarityHashType::PEHash);
        }
        if lower == "importhash" {
            return Ok(SimilarityHashType::ImportHash);
        }
        if lower == "importhashfuzzy" {
            return Ok(SimilarityHashType::FuzzyImportHash);
        }

        Err("known similarity hash type")
    }
}*/

impl Display for SimilarityHashType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            SimilarityHashType::SSDeep => write!(f, "SSDeep"),
            SimilarityHashType::SDHash => write!(f, "SDHash"),
            SimilarityHashType::LZJD => write!(f, "LZJD"),
            SimilarityHashType::TLSH => write!(f, "TLSH"),
            SimilarityHashType::PEHash => write!(f, "PeHash"),
            SimilarityHashType::ImportHash => write!(f, "Import Hash (IMPHASH)"),
            SimilarityHashType::FuzzyImportHash => write!(f, "Fuzzy Import hash"),
        }
    }
}

/// Requesting a sample from MalwareDB
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SimilarSamplesRequest {
    /// User's API key, must be validated before anything else
    pub key: String,

    /// The hash of the requested sample
    pub hash: Vec<(SimilarityHashType, String)>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SimilarSample {
    /// The SHA-256 hash of the found sample
    pub sha256: String,

    /// Matches from the requested sample to this sample by algorithm and score
    pub algorithms: Vec<(SimilarityHashType, f32)>,
}

/// Response indicating samples which are similar
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SimilarSamplesResponse {
    /// The responses
    pub results: Vec<SimilarSample>,

    /// Possible messages from the server, if any
    pub message: Option<String>,
}

/// API endpoint for finding samples which are similar to specific file, POST
pub const LIST_LABELS: &str = "/v1/labels";

/// A label, used for sources and samples
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Label {
    /// Label ID
    pub id: u64,

    /// Label value
    pub name: String,

    /// Label parent
    pub parent: Option<String>,
}

/// One or more labels
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct Labels(pub Vec<Label>);

// Convenience functions
impl Labels {
    pub fn len(&self) -> usize {
        self.0.len()
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }
}

impl Display for Labels {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if self.is_empty() {
            return writeln!(f, "No labels.");
        }
        for label in &self.0 {
            let parent = if let Some(parent) = &label.parent {
                format!(", parent: {parent}")
            } else {
                String::new()
            };
            writeln!(f, "{}: {}{parent}", label.id, label.name)?;
        }
        Ok(())
    }
}