use sha1::{Digest, Sha1};

#[derive(PartialEq, Debug)]

#[allow(non_camel_case_types)]

#[allow(clippy::upper_case_acronyms)]

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)]

#[allow(clippy::upper_case_acronyms)]

enum dir_state {

    DDOT,

    DH,

    DHGDI,

    DDEFAULT,

}

trait Sink {

    fn write_byte(&mut self, c: u8);

    fn write_bytes(&mut self, c: &[u8]);

}

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

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

}

const MAXENCODE: usize = 4096 * 4;

struct DestArr<const N: usize> {

    buf: [u8; N],

    pub len: usize,

}

impl<const N: usize> DestArr<N> {

    pub fn create() -> Self {

        DestArr {

            buf: [0; N],

            len: 0,

        }

    }

    pub fn contents(&self) -> &[u8] {

        &self.buf[..self.len]

    }

}

impl<const N: usize> Sink for DestArr<N> {

    fn write_byte(&mut self, c: u8) {

        self.buf[self.len] = c;

        self.len += 1;

    }

    fn write_bytes(&mut self, src: &[u8]) {

        self.buf[self.len..self.len + src.len()].copy_from_slice(src);

        self.len += src.len();

    }

}

struct MeasureDest {

    pub len: usize,

}

impl Sink for Vec<u8> {

    fn write_byte(&mut self, c: u8) {

        self.push(c)

    }

    fn write_bytes(&mut self, src: &[u8]) {

        self.extend_from_slice(src)

    }

}

impl MeasureDest {

    fn create() -> Self {

        Self { len: 0 }

    }

}

impl Sink for MeasureDest {

    fn write_byte(&mut self, _c: u8) {

        self.len += 1;

    }

    fn write_bytes(&mut self, src: &[u8]) {

        self.len += src.len();

    }

}

fn hexencode(dest: &mut impl Sink, c: u8) {

    let hexdigit = b"0123456789abcdef";

    dest.write_byte(hexdigit[(c as usize) >> 4]);

    dest.write_byte(hexdigit[(c as usize) & 15]);

}

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

fn escape3(dest: &mut impl Sink, c: u8) {

    dest.write_byte(b'~');

    hexencode(dest, c);

}

fn encode_dir(dest: &mut impl Sink, src: &[u8]) {

    let mut state = dir_state::DDEFAULT;

    let mut i = 0;

    while i < src.len() {

        match state {

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

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

                    state = dir_state::DHGDI;

                    dest.write_byte(src[i]);

                    i += 1;

                }

                b'h' => {

                    state = dir_state::DH;

                    dest.write_byte(src[i]);

                    i += 1;

                }

                _ => {

                    state = dir_state::DDEFAULT;

                }

            },

            dir_state::DH => {

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

                    state = dir_state::DHGDI;

                    dest.write_byte(src[i]);

                    i += 1;

                } else {

                    state = dir_state::DDEFAULT;

                }

            }

            dir_state::DHGDI => {

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

                    dest.write_bytes(b".hg");

                    dest.write_byte(src[i]);

                    i += 1;

                }

                state = dir_state::DDEFAULT;

            }

            dir_state::DDEFAULT => {

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

                    state = dir_state::DDOT

                }

                dest.write_byte(src[i]);

                i += 1;

            }

        }

    }

}

fn _encode(

    twobytes: &[u32; 8],

    onebyte: &[u32; 8],

    dest: &mut impl Sink,

    src: &[u8],

    encodedir: bool,

) {

    let mut state = path_state::START;

    let mut i = 0;

    let len = src.len();

    while i < len {

        match state {

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

                b'/' => {

                    dest.write_byte(src[i]);

                    i += 1;

                }

                b'.' => {

                    state = path_state::LDOT;

                    escape3(dest, src[i]);

                    i += 1;

                }

                b' ' => {

                    state = path_state::DEFAULT;

                    escape3(dest, src[i]);

                    i += 1;

                }

                b'a' => {

                    state = path_state::A;

                    dest.write_byte(src[i]);

                    i += 1;

                }

                b'c' => {

                    state = path_state::C;

                    dest.write_byte(src[i]);

                    i += 1;

                }

                b'l' => {

                    state = path_state::L;

                    dest.write_byte(src[i]);

                    i += 1;

                }

                b'n' => {

                    state = path_state::N;

                    dest.write_byte(src[i]);

                    i += 1;

                }

                b'p' => {

                    state = path_state::P;

                    dest.write_byte(src[i]);

                    i += 1;

                }

                _ => {

                    state = path_state::DEFAULT;

                }

            },

            path_state::A => {

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

                    state = path_state::AU;

                    dest.write_byte(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(dest, src[i - 1]),

                    _ => i -= 1,

                }

            }

            path_state::C => {

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

                    state = path_state::CO;

                    dest.write_byte(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;

                    dest.write_byte(src[i - 1]);

                }

            }

            path_state::COMLPTn => {

                state = path_state::DEFAULT;

                match src[i] {

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

                        escape3(dest, src[i - 2]);

                        dest.write_byte(src[i - 1]);

                    }

                    _ => {

                        dest.write_bytes(&src[i - 2..i]);

                    }

                }

            }

            path_state::L => {

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

                    state = path_state::LP;

                    dest.write_byte(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;

                    dest.write_byte(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;

                    dest.write_byte(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' => {