br-code 0.1.7

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;
use ril::{Image as ril_Image, ImageFormat as ril_ImageFormat, Rgb as ril_Rgb};

/// EAN13
pub fn barcode_create_ean13(code: &str, mode: &str, filename: &str) -> Result<bool, String> {
    match EAN13::new(code) {
        Ok(ean13) => {
            let mut encoded: Vec<u8> = ean13.encode();
            let t = match mode {
                "svg" => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    fs::write(filename, data).is_ok()
                }
                "png" => {
                    let mut list = vec![];
                    let index = 5;
                    for _ in 0..5 {
                        encoded.insert(0, 0);
                        encoded.push(0);
                    }
                    let mut top = encoded.clone();
                    top.fill(0);
                    for _ in 0..5 {
                        list.push(top.clone());
                    }
                    for _ in 0..50 {
                        list.push(encoded.clone())
                    }
                    for _ in 0..5 {
                        let mut tt = top.clone();
                        tt[index] = 1;
                        tt[index + 2] = 1;
                        let len = tt.len() / 2 - 10;
                        tt[index + len] = 1;
                        tt[index + len + 2] = 1;

                        let ind = tt.len() - index - 1;
                        tt[ind] = 1;
                        tt[ind - 2] = 1;
                        list.push(tt.clone())
                    }
                    for _ in 0..5 {
                        list.push(top.clone());
                    }

                    let image = ril_Image::from_fn(encoded.len() as u32, list.len() as u32, |w, h| {
                        if list[h as usize][w as usize] == 0 {
                            ril_Rgb::new(255, 255, 255)
                        } else {
                            ril_Rgb::new(0, 0, 0)
                        }
                    });
                    image.save(ril_ImageFormat::Png, filename).is_ok()
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    fs::write(filename, data).is_ok()
                }
            };
            Ok(t)
        }
        Err(e) => Err(e.to_string()),
    }
}

/// 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();
                    fs::write(filename, data).is_ok()
                }
                "png" => {
                    let png = Image::png(20);
                    let bytes = png.generate(&encoded[..]).unwrap();
                    fs::write(filename, bytes).is_ok()
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    fs::write(filename, data).is_ok()
                }
            }
        }
        Err(e) => {
            println!("{}", e);
            false
        }
    }
}

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

/// 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();
                    fs::write(filename, data).is_ok()
                }
                "png" => {
                    let png = Image::png(80); // You must specify the height in pixels.
                    let bytes = png.generate(&encoded[..]).unwrap();
                    fs::write(filename, bytes).is_ok()
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    fs::write(filename, data).is_ok()
                }
            }
        }
        Err(e) => {
            println!("{}", e);
            false
        }
    }
}

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

    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();
                    fs::write(filename, data).is_ok()
                }
                "png" => {
                    let png = Image::png(80);
                    let bytes = png.generate(&encoded[..]).unwrap();
                    fs::write(filename, bytes).is_ok()
                }
                _ => {
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    fs::write(filename, data).is_ok()
                }
            }
        }
        Err(e) => {
            println!("{}", e);
            false
        }
    }
}

pub fn create_barcode(code: &str) -> String {
    let len = code.len();
    match len {
        8 => {
            match EAN8::new(code) {
                Ok(ean8) => {
                    let encoded: Vec<u8> = ean8.encode();
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    data
                }
                Err(_) => {
                    "".to_string()
                }
            }
        }
        13 => {
            match EAN13::new(code) {
                Ok(ean13) => {
                    let encoded: Vec<u8> = ean13.encode();
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    data
                }
                Err(_) => {
                    "".to_string()
                }
            }
        }
        _ => {
            match Code93::new(code) {
                Ok(barcode) => {
                    let encoded = barcode.encode();
                    let svg = SVG::new(80);
                    let data: String = svg.generate(&encoded).unwrap();
                    data
                }
                Err(_) => {
                    "".to_string()
                }
            }
        }
    }
}

/// 创建code编码
pub fn create_barcode_12(code12: &str) -> String {
    let digits: Vec<u32> = code12.chars().map(|c| c.to_digit(10).unwrap()).collect();
    let mut sum = 0;

    for (i, d) in digits.iter().rev().enumerate() {
        if i % 2 == 0 {
            sum += d * 3; // 右1位开始奇数位
        } else {
            sum += d;
        }
    }
    format!("{code12}{}", ((10 - (sum % 10)) % 10) as u8)
}

#[test]
fn barcode() {
    let i = barcode_create_code39("1231231312312312", "svg", "./examples/code39.svg");
    println!("{}", i.unwrap());
    let i = barcode_create_code39("1231231312312312", "png", "./examples/code39.png");
    println!("{}", i.unwrap());
    let i = barcode_create_ean13("123456789123", "png", "./examples/ean13.png");
    println!("{}", i.unwrap());
    let i = barcode_create_code93("123456789011", "png", "./examples/code93.png");
    println!("{}", i);
}