extern crate tempfile;

use std::fs::File;
use std::fs;
use std::io::{Write, Read, Seek, SeekFrom};
use std::process::Command;
use tempfile::NamedTempFile;
use std::fmt;

pub enum Markers {
    Point,
    Pixel,
    Circle,
    Triangle_Down,
    Triangle_Up,
    Triangle_Left,
    Triangle_Right,
    Tri_Down,
    Tri_Up,
    Tri_Left,
    Tri_Right,
    Square,
    Pentagon,
    Star,
    Hexagon1,
    Hexagon2,
    Plus,
    X ,
    Diamond,
    Thin_Diamond,
    VLine,
    HLine,
}

trait AsString {
    fn as_str(&self) -> &str;
}

impl Markers {
    pub fn as_str(&self) -> &str {
        match self {
            &Markers::Point => ".", 	// point marker
            &Markers::Pixel => ",", 	// pixel marker
            &Markers::Circle => "o", 	// circle marker
            &Markers::Triangle_Down => "v",  // triangle_down marker
            &Markers::Triangle_Up => "^", 	// triangle_up marker
            &Markers::Triangle_Left => "<",  //triangle_left marker
            &Markers::Triangle_Right => ">", // triangle_right marker
            &Markers::Tri_Down => "1",  // tri_down marker
            &Markers::Tri_Up => "2", // tri_up marker
            &Markers::Tri_Left => "3", // tri_left marker
            &Markers::Tri_Right => "4", // tri_right marker
            &Markers::Square => "s", // square marker
            &Markers::Pentagon => "p", // pentagon marker
            &Markers::Star => "*", // star marker
            &Markers::Hexagon1 => "h", // hexagon1 marker
            &Markers::Hexagon2 => "H", // hexagon2 marker
            &Markers::Plus => "+", // plus marker
            &Markers::X => "x", // x marker
            &Markers::Diamond => "D", // diamond marker
            &Markers::Thin_Diamond => "d", // thin_diamond marker
            &Markers::VLine => "|", // vline marker
            &Markers::HLine => "_", // hline marker
        }
    }
}

pub enum LineStyle {
    Dot,
    DashDot,
    Dash,
    Fill,
}

impl LineStyle {
    pub fn as_str(&self) -> &str {
        match self {
            &LineStyle::Dot => ":",
            &LineStyle::DashDot => "-.",
            &LineStyle::Dash => "--",
            &LineStyle::Fill => "-",
        }
    }
}

pub struct Figure {
    script: String
}

impl Figure {

    pub fn new() -> Figure {
        return Figure {
            script: "import matplotlib\nimport matplotlib.pyplot as plt\n\n".to_string()
        }   
    }

    pub fn add_plot(&mut self, p: String) {
        self.script += &p;
    }

    pub fn save(&mut self, output: &str) {
        self.script += &format!("plt.savefig('{}')\n", output);
        // create a temporary file
        let mut tmpfile: NamedTempFile = tempfile::NamedTempFile::new().unwrap();
        tmpfile.write_all(self.script.as_bytes());
        print!("{:?}", self.script);

        let mut echo_hello = Command::new("/usr/local/bin/python3");
        echo_hello.arg(tmpfile.path());
        echo_hello.output().expect("failed to execute process");

    }
}

pub struct LinePlotOptions {
    pub marker: Option<Markers>,
    pub lineStyle: Option<LineStyle>,
}

impl LinePlotOptions {
    pub fn new() -> LinePlotOptions {
        return LinePlotOptions {
            marker: None,
            lineStyle: None,
        }
    }
}

pub struct ScatterPlotOptions {
    pub marker: Option<Markers>,
    pub alpha: Option<f64>,
}

impl ScatterPlotOptions {
    pub fn new() -> ScatterPlotOptions {
        return ScatterPlotOptions {
            marker: None,
            alpha: None,
        }
    }
}

impl fmt::Display for LinePlotOptions {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let mut options : Vec<String> = Vec::new();
        match self.marker {
            Some(ref m) => {options.push(format!("marker='{}'", m.as_str()));}
            None => {}
        }
        match self.lineStyle {
            Some(ref v) => {options.push(format!("linestyle='{}'", v.as_str()));}
            None => {}
        }
        fmt.write_str(&options.join(", "));
        Ok(())
    }
}

impl fmt::Display for ScatterPlotOptions {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let mut options : Vec<String> = Vec::new();
        match self.marker {
            Some(ref m) => {options.push(format!("marker='{}'", m.as_str()));}
            None => {}
        }
        match self.alpha {
            Some(ref m) => {options.push(format!("alpha={}", m.to_string()));}
            None => {}
        }
        fmt.write_str(&options.join(", "));
        Ok(())
    }
}

fn convert_list_str<T>(x: Vec<T>) -> String where T: ToString {
    let mut result:Vec<String> = Vec::new();
    for _x in x { result.push(_x.to_string()); }
    return "[".to_string() + &result.join(", ") + &"]".to_string();
}

pub fn line_plot<U, T>(x: Vec<U>, y: Vec<T>, options: Option<LinePlotOptions>) -> String where U: ToString, T: ToString {
    let xs = convert_list_str::<U>(x);
    let ys = convert_list_str::<T>(y);
    match options {
        Some(opt) => {
            return format!("plt.plot({},{},{})\n", xs, ys, opt);
        },
        None => {
            return format!("plt.plot({},{})\n", xs, ys);
        }
    }
}

pub fn scatter_plot<U, T>(x: Vec<U>, y: Vec<T>, options: Option<ScatterPlotOptions>) -> String where U: ToString, T: ToString {
    let xs = convert_list_str::<U>(x);
    let ys = convert_list_str::<T>(y);
        match options {
        Some(opt) => {
            return format!("plt.scatter({},{},{})\n", xs, ys, opt);
        },
        None => {
            return format!("plt.scatter({},{})\n", xs, ys);
        }
    }
    
}

#[cfg(test)]
mod lineplot {
    use super::*;

    #[test]
    fn create_lineplot_basic() {
        let x = vec![1, 2, 3, 4];
        let y = vec![0.1, 0.2, 0.5, 0.3];
        let lp = line_plot::<i32, f64>(x, y, None);
        let mut figure = Figure::new();
        figure.add_plot(lp.clone());
        figure.add_plot(lp.clone());
        print!("{:?}", figure.save("./examples/lineplot_basic.png"));
    }

     #[test]
    fn create_lineplot_basic_markers() {
        let x = vec![1, 2, 3, 4];
        let y = vec![0.1, 0.2, 0.5, 0.3];
        let mut options = LinePlotOptions::new();
        options.marker = Some(Markers::Diamond);
        let lp = line_plot::<i32, f64>(x, y, Some(options));
        let mut figure = Figure::new();
        figure.add_plot(lp.clone());
        figure.add_plot(lp.clone());
        print!("{:?}", figure.save("./examples/lineplot_basic_markers.png"));
    }

     #[test]
    fn create_lineplot_basic_linestyle() {
        let x = vec![1, 2, 3, 4];
        let y = vec![0.1, 0.2, 0.5, 0.3];
        let mut options = LinePlotOptions::new();
        options.marker = Some(Markers::Diamond);
        options.lineStyle = Some(LineStyle::DashDot);
        let lp = line_plot::<i32, f64>(x, y, Some(options));
        let mut figure = Figure::new();
        figure.add_plot(lp.clone());
        figure.add_plot(lp.clone());
        print!("{:?}", figure.save("./examples/lineplot_basic_linestyle.png"));
    }

    #[test]
    fn create_scatterplot_basic() {
        let x = vec![1, 2, 3, 4];
        let y = vec![0.1, 0.2, 0.5, 0.3];
        let lp = scatter_plot::<i32, f64>(x, y, None);
        let mut figure = Figure::new();
        figure.add_plot(lp.clone());
        print!("{:?}", figure.save("./examples/scatterplot_basic.png"));
    }

    #[test]
    fn create_scatterplot_marker() {
        let x = vec![1, 2, 3, 4];
        let y = vec![0.1, 0.2, 0.5, 0.3];
        let mut options = ScatterPlotOptions::new();
        options.marker = Some(Markers::Diamond);
        let lp = scatter_plot::<i32, f64>(x, y, Some(options));
        let mut figure = Figure::new();
        figure.add_plot(lp.clone());
        print!("{:?}", figure.save("./examples/scatterplot_marker.png"));
    }
    #[test]
    fn create_scatterplot_marker_alpha() {
        let x = vec![1, 2, 3, 4];
        let y = vec![0.1, 0.2, 0.5, 0.3];
        let mut options = ScatterPlotOptions::new();
        options.marker = Some(Markers::Diamond);
        options.alpha = Some(0.1);
        let lp = scatter_plot::<i32, f64>(x, y, Some(options));
        let mut figure = Figure::new();
        figure.add_plot(lp.clone());
        print!("{:?}", figure.save("./examples/scatterplot_marker_alpha.png"));
    }


}

fn main() {
    println!("Hello, world!");
}