use pdf::{file::Storage, object::Resolve, object::Stream, primitive::Dictionary};

fn _test(trailer: Dictionary, storage: Storage<Vec<u8>>) {
    println!("Trailer");
    let mut root_ref = None;
    let mut info_ref = None;

    for (key, value) in &trailer {
        println!("{}: {}", key, value);
        match key.as_str() {
            "Root" => {
                root_ref = Some(
                    value
                        .clone()
                        .to_reference()
                        .expect("Expect `Root` to be reference"),
                );
            }
            "Info" => {
                info_ref = Some(
                    value
                        .clone()
                        .to_reference()
                        .expect("Expect `Info` to be reference"),
                );
            }
            _ => {}
        }
    }
    let root_ref = root_ref.expect("Expected `Root` in trailer");
    let info_ref = info_ref.expect("Expected `Info` in trailer");
    println!("root_ref: {:?}", root_ref);
    println!("info_ref: {:?}", info_ref);

    let root = storage
        .resolve(root_ref)
        .expect("Expected `Root` reference to be valid")
        .to_dictionary(&storage)
        .expect("Expected `Root` to be a dictionary");
    let info = storage
        .resolve(info_ref)
        .expect("Expected `Info` reference to be valid")
        .to_dictionary(&storage)
        .expect("Expected `Info` to be a dictionary");
    println!("root: {:?}", root);
    println!("info: {:?}", info);

    let mut pages_ref = None;
    let mut metadata_ref = None;
    for (key, value) in &root {
        println!("{}: {}", key, value);
        match key.as_str() {
            "Pages" => {
                pages_ref = Some(
                    value
                        .clone()
                        .to_reference()
                        .expect("Expected `Pages` to be a reference"),
                );
            }
            "Metadata" => {
                metadata_ref = Some(
                    value
                        .clone()
                        .to_reference()
                        .expect("Expected `Metadata` to be a reference"),
                );
            }
            _ => {}
        }
    }

    let pages_ref = pages_ref.expect("Expected `Pages` in `Root`");
    let metadata_ref = metadata_ref.expect("Expected `Metadata` in `Root");
    println!("{:?}", pages_ref);
    println!("{:?}", metadata_ref);

    let pages = storage
        .resolve(pages_ref)
        .expect("Expected `Pages` reference to be valid")
        .to_dictionary(&storage)
        .expect("Expected `Pages` to be a dictionary");

    let metadata = storage
        .resolve(metadata_ref)
        .expect("Expected `Metadata` reference to be valid")
        .to_stream(&storage)
        .expect("Expected `Metadata` to be a dictionary");

    println!("metadata: {:?}", &metadata.info);
    println!(
        "```metadata\n{}\n```",
        std::str::from_utf8(&metadata.data).expect("Expect `Metadata` to be a valid utf-8 stream")
    );
    println!("pages: {:?}", pages);

    let mut pages_kids = None;
    for (key, value) in &pages {
        if key.as_str() == "Kids" {
            pages_kids = Some(
                value
                    .clone()
                    .to_array(&storage)
                    .expect("Expect `Pages`.`Kids` to be an array"),
            );
        }
    }

    let pages_kids = pages_kids.expect("Expect `Pages.Kids` to exist");
    for kid_ref in pages_kids {
        println!("{:?}", kid_ref);
        let kid = kid_ref
            .to_dictionary(&storage)
            .expect("Expect `Kids` entry to be a dictionary");

        println!("{:?}", kid);

        let mut contents_ref = None;
        let mut resources = None;
        for (key, value) in kid.iter() {
            match key.as_str() {
                "Contents" => {
                    contents_ref = Some(
                        value
                            .clone()
                            .to_reference()
                            .expect("Expect `Contents` to be a reference"),
                    );
                }
                "Resources" => {
                    resources = Some(
                        value
                            .clone()
                            .to_dictionary(&storage)
                            .expect("Expected `Metadata` to be a reference"),
                    );
                }
                _ => {}
            }
        }

        let resources = resources.expect("Expected `Resources` in `Page`");
        let contents_ref = contents_ref.expect("Expected `Contents` in `Page`");

        println!("resources: {:?}", resources);

        let mut ext_g_state = None;
        let mut font = None;
        for (key, value) in &resources {
            match key.as_str() {
                "Font" => {
                    font = Some(
                        value
                            .clone()
                            .to_dictionary(&storage)
                            .expect("Expect `Contents` to be a reference"),
                    );
                }
                "ExtGState" => {
                    ext_g_state = Some(
                        value
                            .clone()
                            .to_dictionary(&storage)
                            .expect("Expected `Metadata` to be a reference"),
                    );
                }
                _ => {}
            }
        }

        let ext_g_state = ext_g_state.expect("Expected `Page`.`ExtGState`");
        let font = font.expect("Expected `Page`.`Font`");

        println!("font: {}", font);

        for (key, value_ref) in &font {
            let value = value_ref
                .clone()
                .to_dictionary(&storage)
                .expect("Expect `Font` entry to be dictionary");
            println!("{}: {:#?}", key, value);

            let mut encoding = None;
            let mut to_unicode_ref = None;
            let mut char_procs = None;
            for (key, value) in &value {
                match key.as_str() {
                    "Encoding" => {
                        encoding = Some(
                            value
                                .clone()
                                .to_dictionary(&storage)
                                .expect("Expect `Encoding` to be a dictionary"),
                        );
                    }
                    "ToUnicode" => {
                        to_unicode_ref = Some(
                            value
                                .clone()
                                .to_reference()
                                .expect("Expected `ToUnicode` to be a reference"),
                        );
                    }
                    "CharProcs" => {
                        char_procs = Some(
                            value
                                .clone()
                                .to_dictionary(&storage)
                                .expect("Expected `CharProcs` to be a dictionary"),
                        );
                    }
                    _ => {}
                }
            }

            println!("to_unicode_ref: {:?}", to_unicode_ref);
            println!("char_procs: {:?}", char_procs);
            println!("encoding: {:?}", encoding);
        }

        println!("ext-g-state: {}", ext_g_state);

        println!("contents_ref: {:?}", contents_ref);

        let contents = storage
            .resolve(contents_ref)
            .expect("Expect `Contents` ref to be valid");
        let contents = contents
            .to_stream(&storage)
            .expect("Expected `Contents` to be stream");
        println!("contents.info{:?}", &contents.info);

        let content_stream =
            Stream::<()>::from_stream(contents, &storage).expect("Expect `Contents` to be valid");
        let decoded = content_stream
            .decode()
            .expect("Expect `Contents` decode to work");
        let decoded_text =
            std::str::from_utf8(&decoded).expect("Expect `Contents` to be valid utf-8");
        println!("decoded_text: {}", decoded_text);
    }
}

fn main() {
    println!("TODO");
}