pub mod annotations;
pub mod callers;
pub mod config;
pub mod in_out;
pub mod sql;
pub mod utils;
pub mod variants;

#[cfg(test)]
mod tests {
    use anyhow::{Ok, Result};
    use indicatif::MultiProgress;
    use indicatif_log_bridge::LogWrapper;
    use log::info;

    use crate::{config::Config, sql::variants_sql::{load_variants_name, remove_variants_names}, variants::{VCFSource, VariantType, Variants, Variant}};

    use super::*;
    #[test]
    fn get_config() -> Result<()> {
        let conf_path = Config::path()?;
        println!("Configuration path {}", conf_path.to_str().unwrap());
        Ok(())
    }

    #[test]
    fn load_from_vcf() -> Result<()> {
        let name = "CAMARA";
        let logger =
            env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
                .build();
        let multi = MultiProgress::new();
        LogWrapper::new(multi.clone(), logger).try_init().unwrap();

        let cfg = Config::get()?;

        let deepvariant_diag_vcf = format!(
            "{}/{name}/diag/DeepVariant/{name}_diag_DeepVariant_PASSED.vcf.gz",
            cfg.longreads_results_dir
        );
        if !std::path::Path::new(&deepvariant_diag_vcf).exists() {
            panic!("{deepvariant_diag_vcf} is required")
        }
        let deepvariant_mrd_vcf = format!(
            "{}/{name}/mrd/DeepVariant/{name}_mrd_DeepVariant_PASSED.vcf.gz",
            cfg.longreads_results_dir
        );
        if !std::path::Path::new(&deepvariant_mrd_vcf).exists() {
            panic!("{deepvariant_mrd_vcf} is required")
        }
        let mrd_bam = format!(
            "{}/{name}/mrd/{name}_mrd_hs1.bam",
            cfg.longreads_results_dir
        );
        if !std::path::Path::new(&mrd_bam).exists() {
            panic!("{mrd_bam} is required")
        }
        let clairs_vcf = format!(
            "{}/{name}/diag/ClairS/{name}_diag_clairs_PASSED.vcf.gz",
            cfg.longreads_results_dir
        );
        if !std::path::Path::new(&clairs_vcf).exists() {
            panic!("{clairs_vcf} is required")
        }
        let clairs_indels_vcf = format!(
            "{}/{name}/diag/ClairS/{name}_diag_clairs_indel_PASSED.vcf.gz",
            cfg.longreads_results_dir
        );
        if !std::path::Path::new(&clairs_indels_vcf).exists() {
            panic!("{clairs_indels_vcf} is required")
        }
        let sniffles_vcf = format!(
            "{}/{name}/diag/Sniffles/{name}_diag_sniffles.vcf",
            cfg.longreads_results_dir
        );
        let sniffles_mrd_vcf = format!(
            "{}/{name}/mrd/Sniffles/{name}_mrd_sniffles.vcf",
            cfg.longreads_results_dir
        );
        if !std::path::Path::new(&sniffles_vcf).exists() {
            panic!("{sniffles_vcf} is required")
        }
        let nanomonsv_vcf = format!(
            "{}/{name}/diag/nanomonsv/{name}_diag_nanomonsv_PASSED.vcf.gz",
            cfg.longreads_results_dir
        );
        if !std::path::Path::new(&nanomonsv_vcf).exists() {
            panic!("{nanomonsv_vcf} is required")
        }

        let db_path = "/data/db_results.sqlite".to_string();
        let loh_path = format!(
            "{}/{name}/diag/{name}_loh.vcf.gz",
            cfg.longreads_results_dir
        );

        let sources = vec![
            (
                deepvariant_diag_vcf.as_str(),
                &VCFSource::DeepVariant,
                &VariantType::Somatic,
            ),
            (
                deepvariant_mrd_vcf.as_str(),
                &VCFSource::DeepVariant,
                &VariantType::Constitutionnal,
            ),
            (
                clairs_vcf.as_str(),
                &VCFSource::ClairS,
                &VariantType::Somatic,
            ),
            (
                sniffles_vcf.as_str(),
                &VCFSource::Sniffles,
                &VariantType::Somatic,
            ),
            (
                sniffles_mrd_vcf.as_str(),
                &VCFSource::Sniffles,
                &VariantType::Constitutionnal,
            ),
            (
                nanomonsv_vcf.as_str(),
                &VCFSource::Nanomonsv,
                &VariantType::Somatic,
            ),
        ];
        let mut variants = Variants::from_vcfs(name.to_string(), sources, &cfg, multi.clone())?;

        variants.vcf_filters();
        variants.write_vcf_cat(&loh_path, &variants::VariantCategory::LOH)?;
        variants.bam_filters(&mrd_bam);
        variants.keep_somatics_un();
        info!("Variants retained: {}", variants.len());

        variants.merge();
        variants.sort()?;
        variants.vep();
        info!("Variants retained: {}", variants.len());

        let gff_path = "/data/ref/hs1/features_not_in_vep.gff.gz";
        variants.annotate_gff_feature(gff_path)?;
        variants.echtvar_annotate(&deepvariant_mrd_vcf)?;

        info!("{:?}", variants.data.get(10));
        variants.filter_snp()?;
        variants.stats()?;

        if std::path::Path::new(&db_path).exists() {
            remove_variants_names(&db_path, &name)?;
        }

        variants.save_sql(&db_path)?;
        variants.stats_sql(&db_path)?;
        info!("Variants : {}", variants.len());

        Ok(())
    }

    #[test]
    fn load_from_db() -> Result<()> {
        let name = "CAMARA";
        let logger =
            env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
                .build();
        let multi = MultiProgress::new();
        LogWrapper::new(multi.clone(), logger).try_init().unwrap();

        let mut variants = load_variants_name(name, &multi)?;
        let v = variants.get_cat(&variants::VariantCategory::Constit);
        let v = v.iter().filter(|v| 0.25 < v.vaf.unwrap() && v.vaf.unwrap() < 0.75 ).map(|v| {

        }).collect::<Vec<Variant>>();

        lev 

        variants.write_vcf_cat("test.vcf.gz", &variants::VariantCategory::Somatic)?;
        println!("{} variants loaded from db.", variants.len());
        Ok(())
    }
}