//! Terminfo 数据库接口。

use std::collections::HashMap;
use std::env;
use std::error;
use std::fmt;
use std::fs::File;
use std::io::{self, prelude::*, BufReader};
use std::path::Path;

use super::color;
use super::Terminal;

use parm::{expand, Param, Variables};
use parser::compiled::{msys_terminfo, parse};
use searcher::get_dbpath_for_term;

/// 解析的 terminfo 数据库条目。
#[allow(unused)]
#[derive(Debug)]
pub(crate) struct TermInfo {
    /// 终端名称
    pub(crate) names: Vec<String>,
    /// 能力名称的 Map 到布尔值
    pub(crate) bools: HashMap<String, bool>,
    /// 能力名称的 Map 到数值
    pub(crate) numbers: HashMap<String, u32>,
    /// 功能名称的 Map 到原始 (unexpanded) 字符串
    pub(crate) strings: HashMap<String, Vec<u8>>,
}

/// terminfo 创建错误。
#[derive(Debug)]
pub(crate) enum Error {
    /// TermUnset 指示环境没有足够的信息来查找 terminfo 条目。
    ///
    TermUnset,
    /// MalformedTerminfo 指示解析 terminfo 条目失败。
    MalformedTerminfo(String),
    /// io::Error 转发在查找或读取 terminfo 条目时遇到的任何 io::Errors。
    IoError(io::Error),
}

impl error::Error for Error {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        use Error::*;
        match self {
            IoError(e) => Some(e),
            _ => None,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use Error::*;
        match *self {
            TermUnset => Ok(()),
            MalformedTerminfo(ref e) => e.fmt(f),
            IoError(ref e) => e.fmt(f),
        }
    }
}

impl TermInfo {
    /// 根据当前环境创建 TermInfo。
    pub(crate) fn from_env() -> Result<TermInfo, Error> {
        let term = match env::var("TERM") {
            Ok(name) => TermInfo::from_name(&name),
            Err(..) => return Err(Error::TermUnset),
        };

        if term.is_err() && env::var("MSYSCON").map_or(false, |s| "mintty.exe" == s) {
            // msys 终端
            Ok(msys_terminfo())
        } else {
            term
        }
    }

    /// 为命名的终端创建 TermInfo。
    pub(crate) fn from_name(name: &str) -> Result<TermInfo, Error> {
        if cfg!(miri) {
            // 避免解析 terminfo 的所有工作 (在 Miri 下非常慢)，并假设标准颜色代码有效 (例如
            // the 'colored' crate).
            return Ok(TermInfo {
                names: Default::default(),
                bools: Default::default(),
                numbers: Default::default(),
                strings: Default::default(),
            });
        }

        get_dbpath_for_term(name)
            .ok_or_else(|| {
                Error::IoError(io::Error::new(io::ErrorKind::NotFound, "terminfo file not found"))
            })
            .and_then(|p| TermInfo::from_path(&(*p)))
    }

    /// 解析给定的 TermInfo。
    pub(crate) fn from_path<P: AsRef<Path>>(path: P) -> Result<TermInfo, Error> {
        Self::_from_path(path.as_ref())
    }
    // 保持元数据较小
    fn _from_path(path: &Path) -> Result<TermInfo, Error> {
        let file = File::open(path).map_err(Error::IoError)?;
        let mut reader = BufReader::new(file);
        parse(&mut reader, false).map_err(Error::MalformedTerminfo)
    }
}

pub(crate) mod searcher;

/// TermInfo 格式解析。
pub(crate) mod parser {
    //! 解析 (term(5)) 的 ncurses 兼容的已编译 terminfo 格式
    pub(crate) mod compiled;
}
pub(crate) mod parm;

/// 一个终端，知道它支持多少种颜色，并对其解析的 Terminfo 数据库记录进行引用。
///
pub(crate) struct TerminfoTerminal<T> {
    num_colors: u32,
    out: T,
    ti: TermInfo,
}

impl<T: Write + Send> Terminal for TerminfoTerminal<T> {
    fn fg(&mut self, color: color::Color) -> io::Result<bool> {
        let color = self.dim_if_necessary(color);
        if cfg!(miri) && color < 8 {
            // Miri 逻辑仅适用于最基本的 8 种颜色，我们只是假设终端将支持。
            // (在 Miri 中 `num_colors` 始终为 0，因此更高的颜色只会失败。
            // 但是 libtest 无论如何都不使用任何更高的颜色。)
            return write!(self.out, "\x1B[3{color}m").and(Ok(true));
        }
        if self.num_colors > color {
            return self.apply_cap("setaf", &[Param::Number(color as i32)]);
        }
        Ok(false)
    }

    fn reset(&mut self) -> io::Result<bool> {
        if cfg!(miri) {
            return write!(self.out, "\x1B[0m").and(Ok(true));
        }
        // 是否有带有 color/attrs 而不是 sgr0 的端子？
        // 尝试回退到 sgr，然后再操作
        let cmd = match ["sgr0", "sgr", "op"].iter().find_map(|cap| self.ti.strings.get(*cap)) {
            Some(op) => match expand(op, &[], &mut Variables::new()) {
                Ok(cmd) => cmd,
                Err(e) => return Err(io::Error::new(io::ErrorKind::InvalidData, e)),
            },
            None => return Ok(false),
        };
        self.out.write_all(&cmd).and(Ok(true))
    }
}

impl<T: Write + Send> TerminfoTerminal<T> {
    /// 使用给定的 TermInfo 和 Write 创建一个新的 TerminfoTerminal。
    pub(crate) fn new_with_terminfo(out: T, terminfo: TermInfo) -> TerminfoTerminal<T> {
        let nc = if terminfo.strings.contains_key("setaf") && terminfo.strings.contains_key("setab")
        {
            terminfo.numbers.get("colors").map_or(0, |&n| n)
        } else {
            0
        };

        TerminfoTerminal { out, ti: terminfo, num_colors: nc }
    }

    /// 使用给定的 Write 为当前环境创建一个新的 TerminfoTerminal。
    ///
    /// 找不到或解析 terminfo 时，返回 `None`。
    pub(crate) fn new(out: T) -> Option<TerminfoTerminal<T>> {
        TermInfo::from_env().map(move |ti| TerminfoTerminal::new_with_terminfo(out, ti)).ok()
    }

    fn dim_if_necessary(&self, color: color::Color) -> color::Color {
        if color >= self.num_colors && (8..16).contains(&color) { color - 8 } else { color }
    }

    fn apply_cap(&mut self, cmd: &str, params: &[Param]) -> io::Result<bool> {
        match self.ti.strings.get(cmd) {
            Some(cmd) => match expand(cmd, params, &mut Variables::new()) {
                Ok(s) => self.out.write_all(&s).and(Ok(true)),
                Err(e) => Err(io::Error::new(io::ErrorKind::InvalidData, e)),
            },
            None => Ok(false),
        }
    }
}

impl<T: Write> Write for TerminfoTerminal<T> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.out.write(buf)
    }

    fn flush(&mut self) -> io::Result<()> {
        self.out.flush()
    }
}