use crypto::digest::Digest;

use crypto::sha1::Sha1;

#[derive(PartialEq, Debug)]

#[allow(non_camel_case_types)]

enum path_state {

    START, /* first byte of a path component */

    A,     /* "AUX" */

    AU,

    THIRD, /* third of a 3-byte sequence, e.g. "AUX", "NUL" */

    C,     /* "CON" or "COMn" */

    CO,

    COMLPT, /* "COM" or "LPT" */

    COMLPTn,

    L,

    LP,

    N,

    NU,

    P, /* "PRN" */

    PR,

    LDOT, /* leading '.' */

    DOT,  /* '.' in a non-leading position */

    H,    /* ".h" */

    HGDI, /* ".hg", ".d", or ".i" */

    SPACE,

    DEFAULT, /* byte of a path component after the first */

}

/* state machine for dir-encoding */

#[allow(non_camel_case_types)]

enum dir_state {

    DDOT,

    DH,

    DHGDI,

    DDEFAULT,

}

fn inset(bitset: &[u32; 8], c: u8) -> bool {

    bitset[(c as usize) >> 5] & (1 << (c & 31)) != 0

}

fn charcopy(dest: Option<&mut [u8]>, destlen: &mut usize, c: u8) {

    if let Some(slice) = dest {

        slice[*destlen] = c

    }

    *destlen += 1

}

fn memcopy(dest: Option<&mut [u8]>, destlen: &mut usize, src: &[u8]) {

    if let Some(slice) = dest {

        slice[*destlen..*destlen + src.len()].copy_from_slice(src)

    }

    *destlen += src.len();

}

fn rewrap_option<'a, 'b: 'a>(

    x: &'a mut Option<&'b mut [u8]>,

) -> Option<&'a mut [u8]> {

    match x {

        None => None,

        Some(y) => Some(y),

    }

}

fn hexencode<'a>(mut dest: Option<&'a mut [u8]>, destlen: &mut usize, c: u8) {

    let hexdigit = b"0123456789abcdef";

    charcopy(

        rewrap_option(&mut dest),

        destlen,

        hexdigit[(c as usize) >> 4],

    );

    charcopy(dest, destlen, hexdigit[(c as usize) & 15]);

}

/* 3-byte escape: tilde followed by two hex digits */

fn escape3(mut dest: Option<&mut [u8]>, destlen: &mut usize, c: u8) {

    charcopy(rewrap_option(&mut dest), destlen, b'~');

    hexencode(dest, destlen, c);

}

fn encode_dir(mut dest: Option<&mut [u8]>, src: &[u8]) -> usize {

    let mut state = dir_state::DDEFAULT;

    let mut i = 0;

    let mut destlen = 0;

    while i < src.len() {

        match state {

            dir_state::DDOT => match src[i] {

                b'd' | b'i' => {

                    state = dir_state::DHGDI;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'h' => {

                    state = dir_state::DH;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                _ => {

                    state = dir_state::DDEFAULT;

                }

            },

            dir_state::DH => {

                if src[i] == b'g' {

                    state = dir_state::DHGDI;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                } else {

                    state = dir_state::DDEFAULT;

                }

            }

            dir_state::DHGDI => {

                if src[i] == b'/' {

                    memcopy(rewrap_option(&mut dest), &mut destlen, b".hg");

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                state = dir_state::DDEFAULT;

            }

            dir_state::DDEFAULT => {

                if src[i] == b'.' {

                    state = dir_state::DDOT

                }

                charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                i += 1;

            }

        }

    }

    destlen

}

fn _encode(

    twobytes: &[u32; 8],

    onebyte: &[u32; 8],

    mut dest: Option<&mut [u8]>,

    src: &[u8],

    encodedir: bool,

) -> usize {

    let mut state = path_state::START;

    let mut i = 0;

    let mut destlen = 0;

    let len = src.len();

    while i < len {

        match state {

            path_state::START => match src[i] {

                b'/' => {

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'.' => {

                    state = path_state::LDOT;

                    escape3(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b' ' => {

                    state = path_state::DEFAULT;

                    escape3(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'a' => {

                    state = path_state::A;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'c' => {

                    state = path_state::C;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'l' => {

                    state = path_state::L;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'n' => {

                    state = path_state::N;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'p' => {

                    state = path_state::P;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                _ => {

                    state = path_state::DEFAULT;

                }

            },

            path_state::A => {

                if src[i] == b'u' {

                    state = path_state::AU;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::AU => {

                if src[i] == b'x' {

                    state = path_state::THIRD;

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::THIRD => {

                state = path_state::DEFAULT;

                match src[i] {

                    b'.' | b'/' | b'\0' => escape3(

                        rewrap_option(&mut dest),

                        &mut destlen,

                        src[i - 1],

                    ),

                    _ => i -= 1,

                }

            }

            path_state::C => {

                if src[i] == b'o' {

                    state = path_state::CO;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::CO => {

                if src[i] == b'm' {

                    state = path_state::COMLPT;

                    i += 1;

                } else if src[i] == b'n' {

                    state = path_state::THIRD;

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::COMLPT => {

                if src[i] >= b'1' && src[i] <= b'9' {

                    state = path_state::COMLPTn;

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                    charcopy(

                        rewrap_option(&mut dest),

                        &mut destlen,

                        src[i - 1],

                    );

                }

            }

            path_state::COMLPTn => {

                state = path_state::DEFAULT;

                match src[i] {

                    b'.' | b'/' | b'\0' => {

                        escape3(

                            rewrap_option(&mut dest),

                            &mut destlen,

                            src[i - 2],

                        );

                        charcopy(

                            rewrap_option(&mut dest),

                            &mut destlen,

                            src[i - 1],

                        );

                    }

                    _ => {

                        memcopy(

                            rewrap_option(&mut dest),

                            &mut destlen,

                            &src[i - 2..i],

                        );

                    }

                }

            }

            path_state::L => {

                if src[i] == b'p' {

                    state = path_state::LP;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::LP => {

                if src[i] == b't' {

                    state = path_state::COMLPT;

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::N => {

                if src[i] == b'u' {

                    state = path_state::NU;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::NU => {

                if src[i] == b'l' {

                    state = path_state::THIRD;

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::P => {

                if src[i] == b'r' {

                    state = path_state::PR;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::PR => {

                if src[i] == b'n' {

                    state = path_state::THIRD;

                    i += 1;

                } else {

                    state = path_state::DEFAULT;

                }

            }

            path_state::LDOT => match src[i] {

                b'd' | b'i' => {

                    state = path_state::HGDI;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                b'h' => {

                    state = path_state::H;

                    charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);

                    i += 1;

                }

                _ => {

                    state = path_state::DEFAULT;