// use super::proj::{ProjectionS, PCS};
use super::Coord;
use super::{Lat, Lon, Range};
use proj::ProjError;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum CoordError {
    #[error("")]
    ProjError {
        #[from]
        source: ProjError,
    },
}

// pub struct LatLonCoord<T: ProjectionS> {
//     actual: (Range, Range),
//     logical: (Range, Range),
//     pcs: PCS<T>,
// }

// impl<T: ProjectionS> LatLonCoord<T> {
//     /// Creates a new `LatLonCoord` instance.
//     ///
//     /// # Arguments
//     ///
//     /// * `lon` - An optional longitude range.
//     /// * `lat` - An optional latitude range.
//     /// * `actual` - A tuple containing the actual ranges.
//     /// * `project` - A projection.
//     ///
//     /// # Returns
//     ///
//     /// A new `LatLonCoord` instance.
//     pub fn new(
//         lon: Option<Range>,
//         lat: Option<Range>,
//         actual: ((i32, i32), (i32, i32)),
//         // actual: (Range, Range),
//         project: T,
//     ) -> Self {
//         let pcs = PCS::new(project, lon, lat);
//         let _box = pcs.bbox().unwrap();
//         Self {
//             actual: (Range::from(actual.0), Range::from(actual.1)),
//             pcs: pcs,
//             logical: _box,
//         }
//     }

//     pub fn set_actual(&mut self, actual: ((i32, i32), (i32, i32))) {
//         self.actual = (Range::from(actual.0), Range::from(actual.1));
//     }

//     pub fn lon_range(&self) -> Range {
//         self.pcs.lon_range
//     }

//     pub fn lat_range(&self) -> Range {
//         self.pcs.lat_range
//     }
// }

// impl<T: ProjectionS> Coord<f64> for LatLonCoord<T> {
//     fn map(&self, axis_1: f64, axis_2: f64) -> super::ScreenCoord {
//         let point = self.pcs.map((axis_1, axis_2));
//         let logical_dim1_span = self.logical.0 .1 - self.logical.0 .0;

//         let dim1_rate = (point.0 - self.logical.0 .0) / logical_dim1_span;
//         let logical_dim2_span = self.logical.1 .1 - self.logical.1 .0;
//         let dim2_rate = (point.1 - self.logical.1 .0) / logical_dim2_span;

//         (
//             (dim1_rate * (self.actual.0 .1 - self.actual.0 .0) as f64) + self.actual.0 .0,
//             (dim2_rate * (self.actual.1 .1 - self.actual.1 .0) as f64) + self.actual.1 .0,
//         )
//     }

//     fn dim1_range(&self) -> (f64, f64) {
//         let v = self.lon_range();
//         (v.0, v.1)
//     }

//     fn dim2_range(&self) -> (f64, f64) {
//         let v = self.lat_range();
//         (v.0, v.1)
//     }
// }
