use std::io;
use std::io::Write;
use std::path::PathBuf;
use std::process;
use std::process::{Command, Stdio};

pub struct Gnuplot;

impl Gnuplot {
    fn exec_plot(
        data: &[[f64; 6]],
        chunk_size: u32,
        start: usize,
        end: usize,
        script: &str,
    ) -> Result<process::Child, io::Error> {
        let mut path = PathBuf::from("gnuplot");
        path.push(script);
        let mut file = std::fs::File::create("data").expect("could not create data file");
        let process = Command::new("gnuplot")
            .args(&[
                "-e",
                format!("states={}; start={}; end={}", chunk_size, start, end).as_ref(),
                "-c",
                path.to_str().unwrap_or(script),
            ])
            .stdin(process::Stdio::piped())
            .stdout(Stdio::piped())
            .spawn()
            .expect("Failed to spawn child process");

        //let stdin = process.stdin.as_mut().expect("Failed to open stdin");
        for line in data {
            let line = format!(
                "{}; {}; {}; {}; {}; {}\n",
                line[0], line[1], line[2], line[3], line[4], line[5]
            );
            file.write_all(line.as_bytes())
                .expect("Failed to write to stdin");
        }
        Ok(process)
    }
}

impl super::Graph for Gnuplot {
    fn plot3d(data: &[[f64; 6]], chunk_size: u32) {
        let iterations = data.len() / chunk_size as usize;
        match Gnuplot::exec_plot(data, chunk_size, 1, iterations, "anim3d.plt") {
            Ok(mut process) => println!("opening gnuplot {:?}", process.wait()),
            Err(err) => println!("failed to start gnuplot: {}", err),
        }
    }
    fn animate3d(data: &[[f64; 6]], chunk_size: u32, start: usize, end: usize) {
        match Gnuplot::exec_plot(data, chunk_size, start, end, "anim3d.plt") {
            Ok(mut process) => println!("opening gnuplot {:?}", process.wait()),
            Err(err) => println!("failed to start gnuplot: {}", err),
        }
    }
    fn plot2d(data: &[[f64; 6]], chunk_size: u32) {
        let iterations = data.len() / chunk_size as usize;
        match Gnuplot::exec_plot(data, chunk_size, 1, iterations, "anim2d.plt") {
            Ok(mut process) => println!("opening gnuplot {:?}", process.wait()),
            Err(err) => println!("failed to start gnuplot: {}", err),
        }
    }
    fn animate2d(data: &[[f64; 6]], chunk_size: u32, start: usize, end: usize) {
        match Gnuplot::exec_plot(data, chunk_size, start, end, "anim2d.plt") {
            Ok(mut process) => println!("opening gnuplot {:?}", process.wait()),
            Err(err) => println!("failed to start gnuplot: {}", err),
        }
    }
}