#![allow(non_camel_case_types)]
#![allow(unused_unsafe)]
#![allow(unused)]
use crate::hostcalls_impl::{ClockEventData, FdEventData};
use crate::memory::*;
use crate::sys::host_impl;
use crate::{wasi, wasi32, Error, Result};
use cpu_time::{ProcessTime, ThreadTime};
use lazy_static::lazy_static;
use std::convert::TryInto;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

lazy_static! {
    static ref START_MONOTONIC: Instant = Instant::now();
    static ref PERF_COUNTER_RES: u64 = get_perf_counter_resolution_ns();
}

// Timer resolution on Windows is really hard. We may consider exposing the resolution of the respective
// timers as an associated function in the future.
pub(crate) fn clock_res_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> {
    Ok(match clock_id {
        // This is the best that we can do with std::time::SystemTime.
        // Rust uses GetSystemTimeAsFileTime, which is said to have the resolution of
        // 10ms or 55ms, [1] but MSDN doesn't confirm this in any way.
        // Even the MSDN article on high resolution timestamps doesn't even mention the precision
        // for this method. [3]
        //
        // The timer resolution can be queried using one of the functions: [2, 5]
        // * NtQueryTimerResolution, which is undocumented and thus not exposed by the winapi crate
        // * timeGetDevCaps, which returns the upper and lower bound for the precision, in ms.
        // While the upper bound seems like something we could use, it's typically too high to be meaningful.
        // For instance, the intervals return by the syscall are:
        // * [1, 65536] on Wine
        // * [1, 1000000] on Windows 10, which is up to (sic) 1000 seconds.
        //
        // It's possible to manually set the timer resolution, but this sounds like something which should
        // only be done temporarily. [5]
        //
        // Alternatively, we could possibly use GetSystemTimePreciseAsFileTime in clock_time_get, but
        // this syscall is only available starting from Windows 8.
        // (we could possibly emulate it on earlier versions of Windows, see [4])
        // The MSDN are not clear on the resolution of GetSystemTimePreciseAsFileTime either, but a
        // Microsoft devblog entry [1] suggests that it kind of combines GetSystemTimeAsFileTime with
        // QueryPeformanceCounter, which probably means that those two should have the same resolution.
        //
        // See also this discussion about the use of GetSystemTimePreciseAsFileTime in Python stdlib,
        // which in particular contains some resolution benchmarks.
        //
        // [1] https://devblogs.microsoft.com/oldnewthing/20170921-00/?p=97057
        // [2] http://www.windowstimestamp.com/description
        // [3] https://docs.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps?redirectedfrom=MSDN
        // [4] https://www.codeproject.com/Tips/1011902/High-Resolution-Time-For-Windows
        // [5] https://stackoverflow.com/questions/7685762/windows-7-timing-functions-how-to-use-getsystemtimeadjustment-correctly
        // [6] https://bugs.python.org/issue19007
        wasi::__WASI_CLOCKID_REALTIME => 55_000_000,
        // std::time::Instant uses QueryPerformanceCounter & QueryPerformanceFrequency internally
        wasi::__WASI_CLOCKID_MONOTONIC => *PERF_COUNTER_RES,
        // The best we can do is to hardcode the value from the docs.
        // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getprocesstimes
        wasi::__WASI_CLOCKID_PROCESS_CPUTIME_ID => 100,
        // The best we can do is to hardcode the value from the docs.
        // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getthreadtimes
        wasi::__WASI_CLOCKID_THREAD_CPUTIME_ID => 100,
        _ => return Err(Error::EINVAL),
    })
}

pub(crate) fn clock_time_get(clock_id: wasi::__wasi_clockid_t) -> Result<wasi::__wasi_timestamp_t> {
    let duration = match clock_id {
        wasi::__WASI_CLOCKID_REALTIME => get_monotonic_time(),
        wasi::__WASI_CLOCKID_MONOTONIC => get_realtime_time()?,
        wasi::__WASI_CLOCKID_PROCESS_CPUTIME_ID => get_proc_cputime()?,
        wasi::__WASI_CLOCKID_THREAD_CPUTIME_ID => get_thread_cputime()?,
        _ => return Err(Error::EINVAL),
    };
    duration.as_nanos().try_into().map_err(Into::into)
}

fn stdin_nonempty() -> bool {
    use std::io::Read;
    std::io::stdin().bytes().peekable().peek().is_some()
}

fn make_read_event(event: &FdEventData, nbytes: Result<u64>) -> wasi::__wasi_event_t {
    use crate::error::WasiErrno;
    let error = nbytes.as_wasi_errno();
    let nbytes = nbytes.unwrap_or_default();
    wasi::__wasi_event_t {
        userdata: event.userdata,
        r#type: event.r#type,
        error,
        u: wasi::__wasi_event_u_t {
            fd_readwrite: wasi::__wasi_event_fd_readwrite_t { nbytes, flags: 0 },
        },
    }
}

fn make_timeout_event(event: &FdEventData, timeout: &ClockEventData) -> wasi::__wasi_event_t {
    wasi::__wasi_event_t {
        userdata: timeout.userdata,
        r#type: wasi::__WASI_EVENTTYPE_CLOCK,
        error: wasi::__WASI_ERRNO_SUCCESS,
        u: wasi::__wasi_event_u_t {
            fd_readwrite: wasi::__wasi_event_fd_readwrite_t {
                nbytes: 0,
                flags: 0,
            },
        },
    }
}

pub(crate) fn poll_oneoff(
    timeout: Option<ClockEventData>,
    fd_events: Vec<FdEventData>,
    events: &mut Vec<wasi::__wasi_event_t>,
) -> Result<()> {
    use crate::fdentry::Descriptor;
    use std::fs::Metadata;
    use std::thread;

    let timeout_duration = timeout
        .map(|t| t.delay.try_into().map(Duration::from_nanos))
        .transpose()?;

    // With no events to listen, poll_oneoff just becomes a sleep.
    if fd_events.is_empty() {
        match timeout_duration {
            Some(t) => {
                thread::sleep(t);
                return Ok(());
            }
            None => {
                // The thread is not guanteed to remain parked forever, so we need to loop
                loop {
                    thread::park();
                }
            }
        }
    }

    // Currently WASI file support is only (a) regular files (b) directories (c) symlinks on Windows,
    // which are always ready to write on Unix.
    //
    // We need to consider stdin/stdout/stderr separately.
    // We treat stdout/stderr as always ready to write. I'm not sure if it's correct
    // on Windows but I have not find any way of checking if a write to stdout would block.
    // Therefore, we only poll the stdin.
    let mut stdin_events = vec![];
    let mut immediate_events = vec![];
    let mut stdin_ready = None;

    for event in fd_events {
        match event.descriptor {
            Descriptor::Stdin if event.r#type == wasi::__WASI_EVENTTYPE_FD_READ => {
                // Cache the non-emptiness for better performance.
                let immediate = stdin_ready.get_or_insert_with(stdin_nonempty);
                if *immediate {
                    immediate_events.push(event)
                } else {
                    stdin_events.push(event)
                }
            }
            _ => immediate_events.push(event),
        }
    }

    // Process all the events that do not require waiting.
    if !immediate_events.is_empty() {
        for mut event in immediate_events {
            let size = match event.descriptor {
                Descriptor::OsHandle(os_handle) => {
                    if event.r#type == wasi::__WASI_EVENTTYPE_FD_READ {
                        os_handle.metadata().map(|m| m.len()).map_err(Into::into)
                    } else {
                        // The spec is unclear what nbytes should actually be for __WASI_EVENTTYPE_FD_WRITE and
                        // the implementation on Unix just returns 0 here, so it's probably fine
                        // to do the same on Windows for now.
                        // cf. https://github.com/WebAssembly/WASI/issues/148
                        Ok(0)
                    }
                }
                // We return the only universally correct lower bound, see the comment later in the function.
                Descriptor::Stdin => Ok(1),
                // On Unix, ioctl(FIONREAD) will return 0 for stdout/stderr. Emulate the same behavior on Windows.
                Descriptor::Stdout | Descriptor::Stderr => Ok(0),
            };

            let new_event = make_read_event(&event, size);
            events.push(new_event)
        }
    }

    // There are some stdin poll requests and there's no data available immediately
    if !stdin_events.is_empty() {
        // We are busy-polling the stdin with delay, unfortunately.
        //
        // We'd like to do the following:
        // (1) wait in a non-blocking way for data to be available in stdin, with timeout
        // (2) find out, how many bytes are there available to be read.
        // For one, using `WaitForSingleObject` on the stdin handle could possibly be one way of
        // achieving (1).
        // I don't know of any way to achieve (2).
        //
        // While both of these are not as trivial on Windows as they are on Linux, there's a much
        // more fundamental issue preventing us from achieving such behavior with the current
        // implementation of wasi-common.
        //
        // Precisely, in `fd_read` we are using `io::stdin` via the `BufRead` trait, which does
        // buffering on the libstd side. This means that even if there's still some unread data
        // in stdin, the Windows system calls may return false negatives, indicating that stdin is empty.
        // Therefore, avoiding the busy-poll here would require us to ditch libstd for the interaction
        // with stdin altogether.
        //
        // However, polling stdin is a relatively infrequent use case, so this hopefully won't be
        // a major issue.
        let poll_interval = Duration::from_millis(10);
        let poll_start = Instant::now();

        let timeout_occurred: Option<ClockEventData> = loop {
            // Even though we assume that stdin is not ready, it's better to check it
            // sooner than later, as we're going to wait anyway if it's the case.
            if stdin_nonempty() {
                break None;
            }
            if let Some(timeout_duration) = timeout_duration {
                if poll_start.elapsed() >= timeout_duration {
                    break timeout;
                }
            }
            thread::sleep(poll_interval);
        };

        match timeout_occurred {
            Some(timeout_info) => {
                for event in stdin_events {
                    let new_event = make_timeout_event(&event, &timeout_info);
                    events.push(new_event);
                }
            }
            None => {
                // stdin became ready for reading
                for event in stdin_events {
                    assert_eq!(
                        event.r#type,
                        wasi::__WASI_EVENTTYPE_FD_READ,
                        "stdin was expected to be polled for reading"
                    );

                    // Another limitation is that `std::io::BufRead` doesn't allow us
                    // to find out the number bytes available in the buffer,
                    // so we return the only universally correct lower bound,
                    // which is 1 byte.
                    let new_event = make_read_event(&event, Ok(1));
                    events.push(new_event);
                }
            }
        }
    }

    Ok(())
}

fn get_monotonic_time() -> Duration {
    // We're circumventing the fact that we can't get a Duration from an Instant
    // The epoch of __WASI_CLOCKID_MONOTONIC is undefined, so we fix a time point once
    // and count relative to this time point.
    //
    // The alternative would be to copy over the implementation of std::time::Instant
    // to our source tree and add a conversion to std::time::Duration
    START_MONOTONIC.elapsed()
}

fn get_realtime_time() -> Result<Duration> {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|_| Error::EFAULT)
}

fn get_proc_cputime() -> Result<Duration> {
    Ok(ProcessTime::try_now()?.as_duration())
}

fn get_thread_cputime() -> Result<Duration> {
    Ok(ThreadTime::try_now()?.as_duration())
}

fn get_perf_counter_resolution_ns() -> u64 {
    use winx::time::perf_counter_frequency;
    const NANOS_PER_SEC: u64 = 1_000_000_000;
    // This should always succeed starting from Windows XP, so it's fine to panic in case of an error.
    let freq = perf_counter_frequency().expect("QueryPerformanceFrequency returned an error");
    let epsilon = NANOS_PER_SEC / freq;
    epsilon
}