pub fn run(

    haplotypes: Vec<PathBuf>,

    mut output: PathBuf,

    prefix: Option<String>,

    csv: bool,

    hide_missing: bool,

    tag_rows: bool,

) -> Result<()> {

    match prefix {

        None => output.push(format!("ht_comparison.csv")),

    let mut names = vec![];

    let mut hts = vec![];

    for path in haplotypes {

        names.push(path.display().to_string());

        hts.push(read_haplotype_file(path)?);

    let aligner = HaplotypeAligner::new(hts, names);

    match csv {

        true => aligner.to_csv(output)?,

    Ok(())

}

    pub fn new(haplotypes: Vec<Vec<HapVariant>>, names: Vec<String>) -> Self {

        let mut last_contig = &haplotypes[0][0].contig;

        // Register all positions first

        let mut positions = vec![];

        for ht in &haplotypes {

            let curr_contig = &ht[0].contig;

            if last_contig != curr_contig {

            }

            last_contig = curr_contig;

            for variant in ht {

                positions.push((variant.pos, vec![None; names.len()]))

        positions.sort();

        positions.dedup();

        // Register present or missing genotypes for each position

        let mut alignment = BTreeMap::from_iter(positions);

        for (k, v) in alignment.iter_mut() {

            for (idx, ht) in haplotypes.iter().enumerate() {

                for var in ht {

                    if k == &var.pos {

                        v[idx] = Some(var.genotype().to_owned());

                    }

        Self { names, alignment }

    }

    fn find_mismatch(&self, v: &[Option<String>]) -> (bool, bool) {

        let mut values = v.iter().flatten().collect::<Vec<&String>>();

        let yellow = values.len() != v.len();

        values.sort();

        values.dedup();

        let red = values.len() > 1;

        (yellow, red)

    }

    pub fn to_csv(&self, path: PathBuf) -> Result<()> {

        let mut wrtr = open_csv_writer(path)?;

        let mut header = vec!["pos".to_string()];

        header.extend(self.names.clone());

        wrtr.write_record(&header)?;

        for (k, v) in &self.alignment {

            let mut record = vec![format!("{k}")];

            v.iter().for_each(|v| match v {

                None => record.push("-".to_string()),

                Some(v) => record.push(v.to_owned()),

            });

            wrtr.write_record(&record)?;

        Ok(())

    }

    fn get_ref_alt() -> (String, String) {

        ("A".to_string(), "T".to_string())

    }

    fn create_haplotype(missing: i64, gt: i64) -> Vec<HapVariant> {

        let mut haps = vec![];

        for i in 0..50 {

            if i % missing != 0 {

                let (reference, alt) = get_ref_alt();

                let gt = match i % gt == 0 {

                    true => 1,

                    false => 0,

                let hap = HapVariant {

                    contig: "".to_string(),

                    pos: i,

                    reference,

                    alt,

                    gt,

                };

                haps.push(hap);

            }

        haps

    }

    #[test]

    fn test_aligner_alignment() {

        let hap1 = create_haplotype(11, 9);

        let hap2 = create_haplotype(2, 10);

        let hap3 = create_haplotype(5, 11);

        let aligner = HaplotypeAligner::new(

            vec![hap1, hap2, hap3],

            vec!["hap1".to_string(), "hap2".to_string(), "hap3".to_string()],

        );

        let pos: Vec<i64> = (1..50).collect();

        let colors = vec![

            (false, false),

            (true, false),

            (false, false),

            (true, false),

            (true, false),

            (true, false),

            (false, false),

            (true, false),

            (false, true),

            (true, false),

        ];

        for (i, (k, v)) in aligner.alignment.iter().enumerate() {

            assert_eq!(&pos[i], k);

            assert_eq!(colors[i], aligner.find_mismatch(v));

            if i == 9 {

                break;

            }

    }

    #[test]

    fn test_aligner_mismatch() {

        let aligner = HaplotypeAligner { names : vec![], alignment: BTreeMap::new() };

        let foo: Vec<Option<String>> = vec![Some("A".into()), None, Some("T".into())];

        let (yellow, red) = aligner.find_mismatch(&foo);

        assert_eq!((yellow, red), (true, true));

        let foo: Vec<Option<String>> = vec![Some("A".into()), Some("A".into()), Some("T".into())];

        let (yellow, red) = aligner.find_mismatch(&foo);

        assert_eq!((yellow, red), (false, true));

        let foo: Vec<Option<String>> = vec![Some("A".into()), None, None];

        let (yellow, red) = aligner.find_mismatch(&foo);

        assert_eq!((yellow, red), (true, false));

        let foo: Vec<Option<String>> = vec![None, None, None];

        let (yellow, red) = aligner.find_mismatch(&foo);

        assert_eq!((yellow, red), (true, false));

        let foo: Vec<Option<String>> = vec![Some("A".into()), Some("A".into()), Some("A".into())];

        let (yellow, red) = aligner.find_mismatch(&foo);

        assert_eq!((yellow, red), (false, false));

    }