use std::fs;
use barcoders::generators::image::Image;
use barcoders::generators::svg::{SVG};
use barcoders::sym::code128::Code128;
use barcoders::sym::code39::Code39;
use barcoders::sym::code93::Code93;
use barcoders::sym::ean13::*;
use barcoders::sym::ean8::EAN8;

/// EAN13
pub fn barcode_create_ean13(code: &str, mode: &str, filename: &str) -> bool {
    match EAN13::new(code) {
        Ok(ean13) => {
            let encoded: Vec<u8> = ean13.encode();
            match mode {
                "svg" => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                "png" => {
                    let png = Image::png(20);
                    let bytes = png.generate(&encoded[..]).unwrap();
                    match fs::write(filename, bytes) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
            }
        }
        Err(e) => {
            println!("{}", e.to_string());
            false
        }
    }
}
/// EAN8
pub fn barcode_create_ean8(code: &str, mode: &str, filename: &str) -> bool {
    match EAN8::new(code) {
        Ok(ean8) => {
            let encoded: Vec<u8> = ean8.encode();
            match mode {
                "svg" => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                "png" => {
                    let png = Image::png(20);
                    let bytes = png.generate(&encoded[..]).unwrap();
                    match fs::write(filename, bytes) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
            }
        }
        Err(e) => {
            println!("{}", e.to_string());
            false
        }
    }
}

/// code39
pub fn barcode_create_code39(code: &str, mode: &str, filename: &str) -> bool {
    match Code39::new(code) {
        Ok(barcode) => {
            let encoded = barcode.encode();
            match mode {
                "svg" => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                "png" => {
                    let png = Image::png(80); // You must specify the height in pixels.
                    let bytes = png.generate(&encoded[..]).unwrap();
                    match fs::write(filename, bytes) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
            }
        }
        Err(e) => {
            println!("{}", e.to_string());
            false
        }
    }
}
/// code93
pub fn barcode_create_code93(code: &str, mode: &str, filename: &str) -> bool {
    match Code93::new(code) {
        Ok(barcode) => {
            let encoded = barcode.encode();
            match mode {
                "svg" => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                "png" => {
                    let png = Image::png(80); // You must specify the height in pixels.
                    let bytes = png.generate(&encoded[..]).unwrap();
                    match fs::write(filename, bytes) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
            }
        }
        Err(e) => {
            println!("{}", e.to_string());
            false
        }
    }
}

/// code128
pub fn barcode_create_code128(code: &str, unit: &str, mode: &str, filename: &str) -> bool {
    let code = match unit {
        "a" => {
            format!("{}", code)
        }
        "b" => {
            format!("{}", code)
        }
        "c" => {
            format!("{}", code)
        }
        _ => {
            format!("{}", code)
        }
    };

    match Code128::new(code) {
        Ok(barcode) => {
            let encoded = barcode.encode();
            match mode {
                "svg" => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                "png" => {
                    let png = Image::png(80);
                    let bytes = png.generate(&encoded[..]).unwrap();
                    match fs::write(filename, bytes) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    match fs::write(filename, data) {
                        Ok(_) => true,
                        Err(_) => false
                    }
                }
            }
        }
        Err(e) => {
            println!("{}", e.to_string());
            false
        }
    }
}