use std::{io, path::PathBuf, sync::Arc};

use alacritty_terminal::{
    event::{OnResize, WindowSize},
    tty::{ChildEvent, EventedPty, EventedReadWrite},
};
use futures::channel::mpsc::UnboundedSender;
use polling::{Event, PollMode, Poller};

use super::pty::PtyEvent;

/// The longest OSC body kept; longer ones are dropped whole.
const MOST: usize = 4096;

/// A pty whose reader hands each byte to an OSC 7 scanner before the parser sees it.
pub(crate) struct Tapped<P> {
    pub inner: P,
    scanner: Osc7,
    events: UnboundedSender<PtyEvent>,
}

impl<P> Tapped<P> {
    pub fn new(inner: P, events: UnboundedSender<PtyEvent>) -> Self {
        Self {
            inner,
            scanner: Osc7::default(),
            events,
        }
    }
}

impl<P: EventedReadWrite> io::Read for Tapped<P> {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let count = self.inner.reader().read(buf)?;
        let events = &self.events;
        self.scanner.feed(&buf[..count], &mut |body| {
            if let Some(folder) = folder(body)
                && events.unbounded_send(PtyEvent::Folder(folder)).is_err()
            {
                log::debug!("pty: a folder report after its session closed");
            }
        });
        Ok(count)
    }
}

impl<P: EventedReadWrite> EventedReadWrite for Tapped<P> {
    type Reader = Self;
    type Writer = P::Writer;

    unsafe fn register(
        &mut self,
        poll: &Arc<Poller>,
        event: Event,
        mode: PollMode,
    ) -> io::Result<()> {
        unsafe { self.inner.register(poll, event, mode) }
    }

    fn reregister(&mut self, poll: &Arc<Poller>, event: Event, mode: PollMode) -> io::Result<()> {
        self.inner.reregister(poll, event, mode)
    }

    fn deregister(&mut self, poll: &Arc<Poller>) -> io::Result<()> {
        self.inner.deregister(poll)
    }

    fn reader(&mut self) -> &mut Self {
        self
    }

    fn writer(&mut self) -> &mut P::Writer {
        self.inner.writer()
    }
}

impl<P: EventedPty> EventedPty for Tapped<P> {
    fn next_child_event(&mut self) -> Option<ChildEvent> {
        self.inner.next_child_event()
    }
}

impl<P: OnResize> OnResize for Tapped<P> {
    fn on_resize(&mut self, size: WindowSize) {
        self.inner.on_resize(size);
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq)]
enum State {
    #[default]
    Ground,
    Escape,
    Osc,
    OscEscape,
}

/// Finds `ESC ] 7 ; body` ended by BEL or `ESC \`, across reads.
#[derive(Default)]
pub(crate) struct Osc7 {
    state: State,
    body: Vec<u8>,
    overflow: bool,
}

impl Osc7 {
    pub fn feed(&mut self, bytes: &[u8], found: &mut impl FnMut(&[u8])) {
        let mut rest = bytes;
        while !rest.is_empty() {
            if self.state == State::Ground {
                match rest.iter().position(|&byte| byte == 0x1b) {
                    Some(at) => {
                        self.state = State::Escape;
                        rest = &rest[at + 1..];
                    }
                    None => return,
                }
                continue;
            }
            let byte = rest[0];
            rest = &rest[1..];
            self.state = match (self.state, byte) {
                (State::Escape, b']') => {
                    self.body.clear();
                    self.overflow = false;
                    State::Osc
                }
                (State::Escape, 0x1b) => State::Escape,
                (State::Escape, _) => State::Ground,
                (State::Osc, 0x07) | (State::OscEscape, b'\\') => {
                    self.finish(found);
                    State::Ground
                }
                (State::Osc | State::OscEscape, 0x18 | 0x1a) => State::Ground,
                (State::Osc, 0x1b) => State::OscEscape,
                (State::OscEscape, b']') => {
                    self.body.clear();
                    self.overflow = false;
                    State::Osc
                }
                (State::OscEscape, 0x1b) => State::Escape,
                (State::OscEscape, _) => State::Ground,
                (State::Osc, byte) => {
                    if self.body.len() < MOST {
                        self.body.push(byte);
                    } else {
                        self.overflow = true;
                    }
                    State::Osc
                }
                (State::Ground, _) => unreachable!("ground scans by position"),
            };
        }
    }

    fn finish(&mut self, found: &mut impl FnMut(&[u8])) {
        if self.overflow {
            log::warn!("pty: an OSC over {MOST} bytes dropped");
        } else if let Some(body) = self.body.strip_prefix(b"7;") {
            found(body);
        }
        self.body.clear();
    }
}

/// The local folder an OSC 7 `file://host/path` names; another host's folder is none.
pub(crate) fn folder(body: &[u8]) -> Option<PathBuf> {
    let Some(rest) = body.strip_prefix(b"file://") else {
        log::warn!(
            "pty: OSC 7 without file:// ({})",
            String::from_utf8_lossy(body)
        );
        return None;
    };
    let slash = rest.iter().position(|&byte| byte == b'/')?;
    let host = String::from_utf8_lossy(&rest[..slash]);
    let local = gethostname::gethostname();
    if !(host.is_empty()
        || host.eq_ignore_ascii_case("localhost")
        || local
            .to_str()
            .is_some_and(|name| host.eq_ignore_ascii_case(name)))
    {
        log::debug!("pty: OSC 7 from host {host}, not this one");
        return None;
    }
    let path = match decode(&rest[slash..]) {
        Some(path) => path,
        None => {
            log::warn!("pty: OSC 7 path is not UTF-8 after decoding");
            return None;
        }
    };
    let drive = path.as_bytes().get(1..3).is_some_and(|two| two[1] == b':')
        && path.as_bytes()[1].is_ascii_alphabetic();
    Some(PathBuf::from(if cfg!(windows) && drive {
        &path[1..]
    } else {
        &path[..]
    }))
}

fn decode(bytes: &[u8]) -> Option<String> {
    let mut out = Vec::with_capacity(bytes.len());
    let mut at = 0;
    while at < bytes.len() {
        let hex = bytes
            .get(at + 1..at + 3)
            .and_then(|two| std::str::from_utf8(two).ok())
            .and_then(|two| u8::from_str_radix(two, 16).ok());
        match (bytes[at], hex) {
            (b'%', Some(value)) => {
                out.push(value);
                at += 3;
            }
            (byte, _) => {
                out.push(byte);
                at += 1;
            }
        }
    }
    String::from_utf8(out).ok()
}

#[cfg(test)]
mod tests {
    use super::*;

    fn scan(chunks: &[&[u8]]) -> Vec<String> {
        let mut scanner = Osc7::default();
        let mut found = Vec::new();
        for chunk in chunks {
            scanner.feed(chunk, &mut |body| {
                found.push(String::from_utf8(body.to_vec()).expect("utf-8"))
            });
        }
        found
    }

    #[test]
    fn finds_osc_7_ended_by_bel_or_st_across_reads() {
        assert_eq!(scan(&[b"ab\x1b]7;file:///a\x07cd"]), ["file:///a"]);
        assert_eq!(scan(&[b"\x1b]7;file:", b"///b\x1b", b"\\"]), ["file:///b"]);
        assert_eq!(scan(&[b"\x1b", b"]7;x\x07\x1b]7;y\x1b\\"]), ["x", "y"]);
    }

    #[test]
    fn other_sequences_and_cancels_pass() {
        assert!(scan(&[b"\x1b]0;title\x07\x1b[31m"]).is_empty());
        assert!(scan(&[b"\x1b]7;file:///a\x18\x07"]).is_empty());
        assert_eq!(scan(&[b"\x1b]7;lost\x1b]7;kept\x07"]), ["kept"]);
    }

    #[test]
    fn an_overlong_body_is_dropped() {
        let mut long = b"\x1b]7;".to_vec();
        long.extend(std::iter::repeat_n(b'a', MOST + 1));
        long.push(0x07);
        assert!(scan(&[&long]).is_empty());
        assert_eq!(scan(&[&long, b"\x1b]7;b\x07"]), ["b"]);
    }

    #[test]
    fn a_local_uri_gives_its_decoded_folder() {
        assert_eq!(
            folder(b"file:///tmp/ely%20dir"),
            Some(PathBuf::from("/tmp/ely dir"))
        );
        assert_eq!(folder(b"file://localhost/x"), Some(PathBuf::from("/x")));
        let host = gethostname::gethostname().into_string().expect("host");
        let named = format!("file://{host}/y");
        assert_eq!(folder(named.as_bytes()), Some(PathBuf::from("/y")));
        assert_eq!(
            folder("file:///%E4%B8%AD".as_bytes()),
            Some(PathBuf::from("/中"))
        );
    }

    #[test]
    fn other_hosts_and_bad_uris_give_none() {
        assert_eq!(folder(b"file://elsewhere.invalid/tmp"), None);
        assert_eq!(folder(b"http://x/y"), None);
        assert_eq!(folder(b"file:///%FF"), None);
    }
}