#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]

#[derive(Debug, Default, Clone, PartialOrd, PartialEq, Eq, Serialize, Deserialize)]

    pub fn genotype(&self) -> &String {

        match self.gt {

            0 => &self.reference,

            1 => &self.alt,

    }

    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

        let line = format!(

            "{}_{}_{}_{}",

            self.contig, self.pos, self.reference, self.alt

        );

        write!(f, "{line}")

    }

    fn eq(&self, other: &HapVariant) -> bool {

        self.contig == other.contig

            && self.pos == other.pos

            && self.reference == other.reference

            && self.alt == other.alt

    }

    fn eq(&self, other: &Coord) -> bool {

        self.contig == other.contig

            && self.pos == other.pos

            && self.reference == other.reference

            && self.alt == other.alt

    }

    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

        let line = format!(

            "{}_{}_{}_{}",

            self.contig, self.pos, self.reference, self.alt

        );

        write!(f, "{line}")

    }

#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, PartialOrd)]

    pub fn haplotype(&self) -> String {

        self.haplotype.iter().fold(String::new(), |string, v| {

            format!("{string}{}", v.genotype())

        })

    }

    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

        let samples = self

            .samples

            .iter()

            .enumerate()

            .fold(String::new(), |string, (i, v)| {

                if i != 0 && i % 15 == 0 {

                    format!("{string} {v}\n")

                    format!("{string} {v}")

            });

        let line = format!("{}:{samples}", self.indexes.len());

        write!(f, "{line}")

    }

    pub fn end(&self) -> usize {

        self.end.unwrap()

    }

    pub fn start(&self) -> usize {

        self.start.unwrap()

    }

    fn as_ref(&self) -> &Self {

        self

    }

    pub fn new(

        variant_idx: usize,

        matrix: Array2<u8>,

        samples: Vec<String>,

        coords: Vec<Coord>,

    ) -> Self {

        Self {

            variant_idx,

            matrix,

            samples,

            coords,

            clinical_data: None,

        }

    }

    pub fn nsamples(&self) -> usize {

        self.samples.len()

    }

    pub fn ncoords(&self) -> usize {

        self.coords.len()

    }

    pub fn samples(&self) -> &Vec<String> {

        &self.samples

    }

    pub fn coords(&self) -> &Vec<Coord> {

        &self.coords

    }

    pub fn coords_mut(&mut self) -> &mut Vec<Coord> {

        &mut self.coords

    }

    pub fn set_coords(&mut self, coords: Vec<Coord>) {

        self.coords = coords;

    }

    pub fn variant_idx(&self) -> usize {

        self.variant_idx

    }

    pub fn set_variant_idx(&mut self, variant_idx: usize) {

        self.variant_idx = variant_idx;

    }

    pub fn variant_idx_pos(&self) -> i64 {

        self.coords[self.variant_idx].pos

    }

    pub fn get_pos(&self, idx: usize) -> i64 {

        self.coords[idx].pos

    }

    pub fn get_contig(&self) -> &String {

        &self.coords[0].contig

    }

        if let Some(idx) = self.coords.iter().position(|c| c.pos >= pos) {

            if idx == 0 { return idx }

            if self.get_pos(idx) == pos { return idx }

            let one_before_idx = idx - 1;

            let before = self.get_pos(one_before_idx);

            let after = self.get_pos(idx);

            if pos - before > after - pos {

                idx

                one_before_idx

            self.coords.len()

    }

    pub fn idx_by_coord(&self, coord: &Coord) -> Option<usize> {

        self.coords.iter().position(|c| c == coord)

    }

    pub fn idx_by_hapvariant(&self, hap: &HapVariant) -> Option<usize> {

        self.coords.iter().position(|coord| coord == hap)

    }

    pub fn matrix(&self) -> &Array2<u8> {

        &self.matrix

    }

    pub fn get_sample_name(&self, index: usize) -> String {

        self.samples.get(index).unwrap().clone()

    }

    pub fn get_sample_names(&self, indexes: &[usize]) -> Vec<String> {

        indexes

            .iter()

            .map(|i| self.samples.get(*i).unwrap())

            .cloned()

            .collect()

    }

    pub fn select_rows(&mut self, mut to_keep: Vec<usize>) {

        to_keep.sort();

        self.matrix = self.matrix.select(Axis(0), &to_keep);

        self.samples = to_keep

            .iter()

            .map(|index| self.samples[*index].clone())

            .collect();

    }

    pub fn select_columns_by_idx(&mut self, to_keep: &mut [usize]) {

        to_keep.sort();

        self.matrix = self.matrix.select(Axis(1), to_keep);

        self.coords = to_keep

            .iter()

            .map(|index| self.coords[*index].clone())

            .collect();

    }

    pub fn select_columns_by_range(&mut self, range: Range<usize>) {

        // Take the first element of the range and subtract from variant_idx

        self.variant_idx -= range.clone().next().unwrap();

        self.matrix = self.matrix.slice(s![.., range.clone()]).to_owned();

        self.coords = self.coords[range].to_vec();

    }

    pub fn find_haplotype_for_sample(

        &self,

        contig: &str,

        range: Range<usize>,

        sample: usize,

    ) -> Vec<HapVariant> {

        range

            .map(|index| HapVariant {

                contig: contig.to_string(),

                pos: self.coords[index].pos,

                alt: self.coords[index].alt.clone(),

                reference: self.coords[index].reference.clone(),

                gt: *self.matrix.slice(ndarray::s![sample, index]).into_scalar(),

            })

            .collect()

    }

    pub fn set_variable_data(&mut self, df: DataFrame) -> Result<()> {

        let raw_utf8 = df["id"].utf8().wrap_err(eyre!("Make sure variable file has an id column"))?;

        let clinical_samples: Vec<_> = raw_utf8.into_iter().flatten().collect();

        for sample in &self.samples {

           if !clinical_samples.contains(&sample.as_str()) {

               tracing::warn!("Sample {sample} is not present in clinical data");

           }

        let names = lit(Series::from_iter(self.samples.clone()));

        let df = df

            .clone()

            .lazy()

            .filter(col("id").is_in(names))

            .collect()?;

        self.clinical_data = Some(df);

        Ok(())

    }

    pub fn get_variable_data_mean(&self, indexes: &[usize], column_names: &[String]) -> Result<Option<Vec<f64>>> {

        let names = self.get_sample_names(indexes);

        let names = lit(Series::from_iter(names));

        if let Some(df) = &self.clinical_data {

            let mut means = Vec::with_capacity(column_names.len());

            for column_name in column_names {

                let mean = df

                    .clone()

                    .lazy()

                    .filter(col("id").is_in(names.clone()))

                    .select([col(column_name).mean()])

                    .collect()?;

                let mean = mean 

                    .column(column_name)?

                    .sum::<f64>()

                    .ok_or(eyre::eyre!("A value {mean:?} cannot be parsed as an f64 in the column {column_name}. This could also mean all values are NA in the column."))?;

                means.push(mean)

            Ok(Some(means))

    }

    pub fn get_variable_data_vecs(&self, indexes: &[usize], column_names: &[String]) -> Result<Option<Vec<Vec<f64>>>> {

        let names = self.get_sample_names(indexes);

        let names = lit(Series::from_iter(names));

        if let Some(df) = &self.clinical_data {

            let mut vecs = Vec::with_capacity(column_names.len());

            for column_name in column_names {

                let df = df

                    .clone()

                    .lazy()

                    .filter(col("id").is_in(names.clone()))

                    .select([col(column_name)])

                    .collect()?;

                if let Ok(vec) = df[column_name.as_str()].f64() {

                } else if let Ok(vec) = df[column_name.as_str()].i64() {

                    let vec: Vec<f64> = vec.into_iter().flatten().map(|v| v as f64).collect();

                    vecs.push(vec)

            Ok(Some(vecs))

    }

    #[test]

    fn test_haplonode_displays() {

        let hn = HaploNode { 

            samples: vec!["S1".to_string(), "S2".to_string()],

            ..Default::default()

        };

        assert_eq!("0: S1 S2".to_string() ,format!("{hn}"))

    }

    #[test]

    fn test_coords_displays() {

        let coord  = Coord { 

            contig: "chr9".to_string(),

            pos: 25,

            reference: "G".to_string(),

            alt: "T".to_string(),

            phase: false,

        };

        assert_eq!("chr9_25_G_T".to_string() ,format!("{coord}"))

    }

    #[test]

    fn test_hapvariant_genotype_getter() {

        let mut hv  = HapVariant { 

            contig: "chr9".to_string(),

            pos: 25,

            reference: "G".to_string(),

            alt: "T".to_string(),

            gt: 1,

        };

        assert_eq!(&"T".to_string(), hv.genotype());

        hv.gt = 0;

        assert_eq!(&"G".to_string(), hv.genotype());

    }