use std::io; 
use printpdf::*;
use std::fs::File;
use std::io::BufWriter;
fn main() {
    println!("Enter: Position");
    let mut position = String::new(); 
    io:: stdin()
        .read_line(&mut position)
        .expect("failed to read"); 
        
    println!("Enter: Company Name");
    let mut coname = String::new(); 
    io:: stdin()
        .read_line(&mut coname)
        .expect("failed to read"); 
    println!("Enter: Company Location");
    let mut location = String::new(); 
    io:: stdin()
        .read_line(&mut location)
        .expect("failed to read"); 
    let ntxt = " ";
    let sample = "This is some random Sample text, This text should eventaully be a user input. Currently, this text is not a user input. this text is supposed to be a text of long string data that will eventually be added to the document via user input";
    let (doc, page1, layer1) = PdfDocument::new("PDF_Document_title", Mm(216.0), Mm(279.0), "Layer 1");
    let current_layer = doc.get_page(page1).get_layer(layer1);
    let font = doc.add_external_font(File::open("./fonts/TNR-Regular.ttf").unwrap()).unwrap();
    current_layer.use_text(position.clone(), 14.0, Mm(25.0), Mm(250.0), &font);
    current_layer.use_text(coname.clone(), 14.0, Mm(25.0), Mm(240.0), &font);
    current_layer.use_text(location.clone(), 14.0, Mm(25.0), Mm(230.0), &font);
    current_layer.use_text(ntxt.clone(), 14.0, Mm(25.0), Mm(220.0), &font);
    current_layer.begin_text_section();
        current_layer.set_font(&font, 14.0);
        current_layer.set_text_cursor(Mm(25.0), Mm(210.0));
        // write one line, but write text2 in superscript
        current_layer.write_text(sample.clone(), &font);
    current_layer.end_text_section();
    doc.save(&mut BufWriter::new(File::create("test_working.pdf").unwrap())).unwrap();
}

use printpdf::*;
use std::fs::File;
use std::io::BufWriter;
use std::io::{self, Read};
fn main() {
    println!("Enter: Position");
    let mut position = String::new();
    io::stdin()
        .read_line(&mut position)
        .expect("failed to read");
    println!("Enter: Company Name");
    let mut coname = String::new();
    io::stdin().read_line(&mut coname).expect("failed to read");
    println!("Enter: Company Location");
    let mut location = String::new();
    io::stdin()
        .read_line(&mut location)
        .expect("failed to read");
    let ntxt = " ";
    let sample = "This is some random Sample text, This text should eventaully be a user input. Currently, this text is not a user input. this text is supposed to be a text of long string data that will eventually be added to the document via user input";
    let (doc, page1, layer1) =
        PdfDocument::new("PDF_Document_title", Mm(216.0), Mm(279.0), "Layer 1");
    let current_layer = doc.get_page(page1).get_layer(layer1);
    // load the font data for the font "Times New Roman"
    let font_data = {
        let mut font_file = File::open("./times-new-roman.ttf").unwrap();
        let mut font_data = Vec::with_capacity(font_file.metadata().unwrap().len() as usize);
        font_file.read_to_end(&mut font_data).unwrap();
        font_data
    };
    // load the font reference for glyph_brush_layout
    let gbl_font = glyph_brush_layout::ab_glyph::FontRef::try_from_slice(&font_data).unwrap();
    // put it into a slice of glyph_brush_layout font references
    let gbl_fonts = &[gbl_font];
    // load the font reference for printpdf
    let font = doc.add_external_font(font_data.as_slice()).unwrap();
    current_layer.use_text(position.clone(), 14.0, Mm(25.0), Mm(250.0), &font);
    current_layer.use_text(coname.clone(), 14.0, Mm(25.0), Mm(240.0), &font);
    current_layer.use_text(location.clone(), 14.0, Mm(25.0), Mm(230.0), &font);
    current_layer.use_text(ntxt, 14.0, Mm(25.0), Mm(220.0), &font);
    // calculate the glyph positions using glyph_brush_layout
    use glyph_brush_layout::ab_glyph::Font;
    use glyph_brush_layout::GlyphPositioner;
    let glyphs = glyph_brush_layout::Layout::default().calculate_glyphs(
        gbl_fonts,
        &glyph_brush_layout::SectionGeometry {
            // width 160mm = 210mm - 2 * 25mm margins; height unbounded
            bounds: (mm_to_px(160.0), f32::INFINITY),
            ..Default::default()
        },
        &[glyph_brush_layout::SectionText {
            text: sample,
            scale: gbl_fonts[0].pt_to_px_scale(14.0).unwrap(),
            font_id: glyph_brush_layout::FontId(0),
        }],
    );
    // make sure the number of glyphs matches the number of chars in the sample text
    assert_eq!(glyphs.len(), sample.chars().count());
    // group the glyphs by y position
    use itertools::Itertools;
    let line_starts = glyphs
        .iter()
        .enumerate() // enumerate will give us the start index into the sample text of the start of the line
        .group_by(|(_, glyph)| glyph.glyph.position.y) // group by "y" which is effectively equivalent to the index of the line
        .into_iter()
        .map(|(y, mut group)| (y, group.next().unwrap().0))
        .collect::<Vec<_>>();
    // get the minimum y position
    // you could get the max a similar way, if you needed to calculate the vertical size of the text,
    // for example if you wanted to lay out text below it
    let min = glyphs
        .iter()
        .map(|glyph| glyph.glyph.position.y)
        .fold(f32::INFINITY, |a, b| a.min(b));
    // we need a peekable iterator so we can see where the next line starts
    let mut iter = line_starts.iter().peekable();
    // iterate over the line_starts and draw the text
    loop {
        // get the next line start, if there is none then we break out of the loop
        let Some((y, start)) = iter.next() else {
            break;
        };
        // peek into the line start after that to get the end index,
        // if there is none (we're at the last line in the loop), then we use the length of the sample text
        let end = if let Some((_, end)) = iter.peek() {
            *end
        } else {
            sample.chars().count()
        };
        // slice up the text
        // if you know you're only dealing with ASCII characters you can simplify this as
        // `let line = &sample[*start..end];`
        // which saves on an allocation to a String;
        // or you can use char_indices to get the byte indices and slice that way
        let line = sample
            .chars()
            .skip(*start)
            .take(end - start)
            .collect::<String>();
        // draw the text
        current_layer.use_text(
            line.trim(),
            14.0,
            Mm(25.0),
            // printpdf up = y positive, but glyph_brush_layout down = y positive
            Mm(210.0 + px_to_mm(min) - px_to_mm(*y)),
            &font,
        );
    }
    doc.save(&mut BufWriter::new(
        File::create("test_working.pdf").unwrap(),
    ))
    .unwrap();
}
/// glyph_brush_layout deals with f32 pixels, but printpdf deals with f64 mm.
fn px_to_mm(px: f32) -> f64 {
    px as f64 * 3175.0 / 12000.0
}
/// printpdf deals with f64 mm, but glyph_brush_layout deals with f32 pixels.
fn mm_to_px(mm: f64) -> f32 {
    (mm * 12000.0 / 3175.0) as f32
}

[package]
name = "generate-pdf"
version = "0.1.0"
edition = "2021"
[dependencies]
glyph_brush_layout = "0.2.3"
itertools = "0.10.5"
printpdf = "0.5.3"