use substring::Substring;

struct Catmin {
    root: String,
    gloss: String,
}

impl Catmin {
    fn to_gender_lexicon(self) -> String {
        format!("\\orth{{{}}} \\hfill {} \\\\",
                self.root,
                self.gloss
        )
    }
}

#[derive(Debug)]
struct RootIdentity {
    sort_key: Vec<usize>,
    root: String,
    search_key: String,
}

fn drsk_letter_at(word: &str, offset: usize)
                  -> Option<(usize, usize)> {
    let alphabetical_order = [
        "s", "y", "p", "tᵗ", "tˣ", "sˢ", "ŋ", "ŋᵘ", "þ", "þʲ", "ť", "ťʲ",
        "a", "k", "kⁱ", "kʲ", "fᶠ", "c", "ć", "cⁱ", "cᶜ", "č",
        "bᵇ", "pᵖ", "m", "mᵘ", "ð", "ðʲ", "ď", "ďʲ", "r", "rⁱ", "nⁱ", "yᵉ", "j",
        "á", "ś", "d", "dʲ", "dᵘ", "ħ", "rʳ", "ó",
        "#", "@", "\\", "\\[", "\\]", "g", "gʲ", "gᵍ", "l", "lⁱ", "lˡ", "ł",
        "iᵉ", "t", "tʲ", "tᵘ", "f", "v", "uᵃ", "o", "b", "kᵏ",
        "z", "h", "u", "n", "nᵘ", "w", "vᵉ", "aʸ", "dᵈ", "é"
    ];

    let two_letter = alphabetical_order.iter()
        .position(|&x| x == word.substring(offset, offset + 2));
    let one_letter = alphabetical_order.iter()
        .position(|&x| x == word.substring(offset, offset + 1));

    if two_letter.is_some() {
        Some((two_letter.unwrap(), 2))
    }
    else if one_letter.is_some() {
        Some((one_letter.unwrap(), 1))
    }
    else { None }
}

fn drsk_alphabetical_sort_key(word: &str) -> Vec<usize> {
    let mut result = Vec::<usize>::new();
    let mut parsed_chars = 0;
    while parsed_chars < word.chars().count() {
        let do_parse = drsk_letter_at(word, parsed_chars);
        if do_parse.is_some() {
            let (pos, parsed) = do_parse.unwrap();
            result.push(pos);
            parsed_chars += parsed;
        }
        else {
            parsed_chars += 1;
            // Error out somehow?
        }
    }
    result
}

impl RootIdentity {
    fn new(search_key: String, root: String) -> RootIdentity {
        let mut sort_key = drsk_alphabetical_sort_key(&root);
        sort_key.push(0);
        RootIdentity {
            root: root,
            search_key: search_key,
            sort_key: sort_key
        }
    }
}

struct Catmaj {
    tightly_bound_catmins: Vec<Catmin>,
    identity: RootIdentity
}
fn main() -> anyhow::Result<()> {
    let catmin = Catmin {
        root: "kⁱc".to_string(),
        gloss: "period 1".to_string(),
    };
    let test_root = RootIdentity::new(
        "SOMETHING".to_string(),
        "lb".to_string());
    println!("{}", catmin.to_gender_lexicon());
    println!("sort: {:?}; search {}; root: {}",
             test_root.sort_key,
             test_root.search_key,
             test_root.root);
    println!("{:?}", drsk_alphabetical_sort_key("prnᵘdlⁱ"));
    println!("{:?}", test_root);
    Ok(())
}