//! Character transcoding support.

use core::str;

use std::borrow::Cow;

use crate::{errors::HgError, utils::Escaped};

use unicode_width::UnicodeWidthStr as _;

/// String encoder and decoder.

#[derive(Copy, Clone, Debug)]

pub struct Encoder {

    /// The user's local encoding.

    local_encoding: Encoding,

    /// What to do when decoding fails. (Encoding always uses

    /// `Mode::Replace`).

    decoding_mode: Mode,

    /// Width to use for characters that can be interpreted either as narrow

    /// or wide depending on the context.

    pub ambiguous_width: Width,

}

/// Character encoding.

#[derive(Copy, Clone, Debug)]

pub enum Encoding {

    Utf8,

    Ascii,

}

/// Character decoding mode.

#[derive(Copy, Clone, Debug)]

pub enum Mode {

    /// Produce an error message for invalid characters.

    Strict,

    /// Replace invalid characters with a special character.

    Replace,

}

/// The width of a Unicode character.

#[derive(Copy, Clone, Debug)]

pub enum Width {

    /// Narrow, taking up 1 terminal column.

    Narrow,

    /// Wide, taking up 2 terminal columns.

    Wide,

}

impl Default for Encoder {

    fn default() -> Self {

        Self {

            local_encoding: Encoding::Utf8,

            decoding_mode: Mode::Strict,

            ambiguous_width: Width::Narrow,

        }

    }

}

impl Encoder {

    /// Creates an encoder from environment variables.

    pub fn from_env() -> Result<Self, HgError> {

        let default = Encoder::default();

        let local_encoding = match std::env::var_os("HGENCODING") {

            None => default.local_encoding,

            Some(s)

                if s.eq_ignore_ascii_case("utf-8")

                    || s.eq_ignore_ascii_case("utf8") =>

            {

                Encoding::Utf8

            }

            Some(s) if s.eq_ignore_ascii_case("ascii") => Encoding::Ascii,

            Some(s) => {

                return Err(HgError::unsupported(format!(

                    "HGENCODING value '{}' is not supported",

                    s.to_string_lossy()

                )))

            }

        };

        let decoding_mode = match std::env::var_os("HGENCODINGMODE") {

            None => default.decoding_mode,

            Some(s) if s == "strict" => Mode::Strict,

            Some(s) if s == "replace" => Mode::Replace,

            Some(s) => {

                return Err(HgError::abort_simple(format!(

                    "HGENCODINGMODE value '{}' is not supported",

                    s.to_string_lossy()

                )))

            }

        };

        let ambiguous_width = match std::env::var_os("HGENCODINGAMBIGUOUS") {

            None => default.ambiguous_width,

            Some(s) if s == "narrow" => Width::Narrow,

            Some(s) if s == "wide" => Width::Wide,

            Some(s) => {

                return Err(HgError::abort_simple(format!(

                    "HGENCODINGAMBIGUOUS value '{}' is not supported",

                    s.to_string_lossy()

                )))

            }

        };

        Ok(Self {

            local_encoding,

            decoding_mode,

            ambiguous_width,

        })

    }

    /// Decodes an internal UTF-8 string from bytes.

    pub fn decode_internal<'a>(

        &self,

        bytes: &'a [u8],

    ) -> Result<&'a str, HgError> {

        decode_utf8(bytes).map_err(HgError::corrupted)

    }

    /// Converts a string from internal UTF-8 to the local character encoding.

    pub fn to_local<'a>(&self, str: &'a str) -> Cow<'a, [u8]> {

        match self.local_encoding {

            Encoding::Utf8 => Cow::Borrowed(str.as_bytes()),

            Encoding::Ascii => {

                if str.is_ascii() {

                    Cow::Borrowed(str.as_bytes())

                } else {

                    Cow::Owned(codepoints_to_ascii_lossy(str).into_bytes())

                }

            }

        }

    }

    /// Converts a string from the local character encoding to UTF-8.

    pub fn from_local<'a>(

        &self,

        bytes: &'a [u8],

    ) -> Result<Cow<'a, str>, HgError> {

        match (self.local_encoding, self.decoding_mode) {

            (Encoding::Utf8, Mode::Strict) => Ok(Cow::Borrowed(

                decode_utf8(bytes).map_err(HgError::abort_simple)?,

            )),

            (Encoding::Utf8, Mode::Replace) => {

                Ok(String::from_utf8_lossy(bytes))

            }

            (Encoding::Ascii, Mode::Strict) => Ok(Cow::Borrowed(

                decode_ascii(bytes).map_err(HgError::abort_simple)?,

            )),

            (Encoding::Ascii, Mode::Replace) => {

                Ok(Cow::Owned(bytes_to_ascii_lossy(bytes)))

            }

        }

    }

    /// Returns the column width of a string for display.

    pub fn column_width(&self, str: &str) -> usize {

        match self.ambiguous_width {

            Width::Narrow => str.width(),

            Width::Wide => str.width_cjk(),

        }

    }

    /// Returns the column width if `bytes` can be decoded as UTF-8, otherwise

    /// just returns the length in bytes.

    pub fn column_width_bytes(&self, bytes: &[u8]) -> usize {

        match str::from_utf8(bytes) {

            Ok(str) => self.column_width(str),

            Err(_) => bytes.len(),

        }

    }

}

/// Decodes bytes as UTF-8 or returns a detailed error message.

fn decode_utf8(bytes: &[u8]) -> Result<&str, String> {

    str::from_utf8(bytes).map_err(|err| {

        format!(

            "invalid UTF-8 at offset {}: \"{}\"",

            err.valid_up_to(),

            str::from_utf8(&bytes.escaped_bytes()).unwrap()

        )

    })

}

/// Decodes bytes as ASCII or returns a detailed error message.

fn decode_ascii(bytes: &[u8]) -> Result<&str, String> {

    // TODO: Use `as_ascii` https://github.com/rust-lang/rust/issues/110998

    if bytes.is_ascii() {

        // Safety: Just checked that it's ASCII.

        let str = unsafe { str::from_utf8_unchecked(bytes) };

        Ok(str)

    } else {

        Err(format!(

            "invalid ASCII: \"{}\"",

            str::from_utf8(&bytes.escaped_bytes()).unwrap()

        ))

    }

}

/// Replaces all non-ASCII codepoints with '?'.

fn codepoints_to_ascii_lossy(str: &str) -> String {

    let mut ascii = String::new();

    for char in str.chars() {

        ascii.push(if char.is_ascii() { char } else { '?' });

    }

    ascii

}

/// Replaces all non-ASCII bytes with '?'.

fn bytes_to_ascii_lossy(bytes: &[u8]) -> String {

    let mut ascii = String::new();

    for &b in bytes {

        ascii.push(if b.is_ascii() { b as char } else { '?' });

    }

    ascii

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn test_decode_internal() {

        let encoder = Encoder::default();

        assert_eq!(encoder.decode_internal(b"").unwrap(), "");

        assert_eq!(encoder.decode_internal(b"\xc3\xa9").unwrap(), "é");

        match encoder.decode_internal(b"A\xc3") {

            Ok(_) => panic!("expected an error"),

            Err(HgError::CorruptedRepository(message)) => {

                assert_eq!(message, "invalid UTF-8 at offset 1: \"A\\xc3\"")

            }

            Err(_) => panic!("expected a CorruptedRepository error"),

        }

    }

    #[test]

    fn test_to_local() {

        let encoder = Encoder::default();

        assert_eq!(encoder.to_local("").as_ref(), b"");

        assert_eq!(encoder.to_local("é").as_ref(), b"\xc3\xa9");

    }

    #[test]

    fn test_from_local() {

        let encoder = Encoder::default();

        assert_eq!(encoder.from_local(b"").unwrap(), "");

        assert_eq!(encoder.from_local(b"\xc3\xa9").unwrap(), "é");

        match encoder.from_local(b"A\xc3") {

            Ok(_) => panic!("expected an error"),

            Err(HgError::Abort { message, .. }) => {

                assert_eq!(message, "invalid UTF-8 at offset 1: \"A\\xc3\"")

            }

            Err(_) => panic!("expected a CorruptedRepository error"),

        }

    }

    #[test]

    fn test_from_local_replace() {

        let encoder = Encoder {

            decoding_mode: Mode::Replace,

            ..Default::default()

        };

        assert_eq!(encoder.from_local(b"A\xc3").unwrap(), "A\u{fffd}");

    }

    #[test]

    fn test_column_width() {

        let encoder = Encoder::default();

        assert_eq!(encoder.column_width(""), 0);

        assert_eq!(encoder.column_width("a"), 1);

        assert_eq!(encoder.column_width("ab"), 2);

        assert_eq!(encoder.column_width("été"), 3);

        assert_eq!(encoder.column_width("\u{1f496}"), 2);

    }

    #[test]

    fn test_column_width_ambiguous() {

        let narrow_encoder = Encoder {

            ambiguous_width: Width::Narrow,

            ..Default::default()

        };

        assert_eq!(narrow_encoder.column_width("\u{2606}"), 1);

        let wide_encoder = Encoder {

            ambiguous_width: Width::Wide,

            ..Default::default()

        };

        assert_eq!(wide_encoder.column_width("\u{2606}"), 2);

    }

    #[test]

    fn test_column_width_bytes() {

        let encoder = Encoder::default();

        assert_eq!(encoder.column_width_bytes(b""), 0);

        assert_eq!(encoder.column_width_bytes("été".as_bytes()), 3);

        assert_eq!(encoder.column_width_bytes(b"A\xc3"), 2);

    }

}