use std::{
    future::Future,
    pin::Pin,
    ptr,
    task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
};

use tree_sitter::Parser;

use super::helpers::fixtures::get_language;

#[test]
fn test_node_across_async_boundaries() {
    let mut parser = Parser::new();
    let language = get_language("bash");
    parser.set_language(&language).unwrap();
    let tree = parser.parse("#", None).unwrap();
    let root = tree.root_node();

    let (result, yields) = simple_async_executor(async {
        let root_ref = &root;

        // Test node captured by value
        let fut_by_value = async {
            yield_once().await;
            root.child(0).unwrap().kind()
        };

        // Test node captured by reference
        let fut_by_ref = async {
            yield_once().await;
            root_ref.child(0).unwrap().kind()
        };

        let result1 = fut_by_value.await;
        let result2 = fut_by_ref.await;

        assert_eq!(result1, result2);
        result1
    });

    assert_eq!(result, "comment");
    assert_eq!(yields, 2);
}

#[test]
fn test_cursor_across_async_boundaries() {
    let mut parser = Parser::new();
    let language = get_language("c");
    parser.set_language(&language).unwrap();
    let tree = parser.parse("#", None).unwrap();
    let mut cursor = tree.walk();

    let ((), yields) = simple_async_executor(async {
        cursor.goto_first_child();

        // Test cursor usage across yield point
        yield_once().await;
        cursor.goto_first_child();

        // Test cursor in async block
        let cursor_ref = &mut cursor;
        let fut = async {
            yield_once().await;
            cursor_ref.goto_first_child();
        };
        fut.await;
    });

    assert_eq!(yields, 2);
}

#[test]
fn test_node_and_cursor_together() {
    let mut parser = Parser::new();
    let language = get_language("javascript");
    parser.set_language(&language).unwrap();
    let tree = parser.parse("#", None).unwrap();
    let root = tree.root_node();
    let mut cursor = tree.walk();

    let ((), yields) = simple_async_executor(async {
        cursor.goto_first_child();

        let fut = async {
            yield_once().await;
            let _ = root.to_sexp();
            cursor.goto_first_child();
        };

        yield_once().await;
        fut.await;
    });

    assert_eq!(yields, 2);
}

fn simple_async_executor<F>(future: F) -> (F::Output, u32)
where
    F: Future,
{
    let waker = noop_waker();
    let mut cx = Context::from_waker(&waker);
    let mut yields = 0;
    let mut future = Box::pin(future);

    loop {
        match future.as_mut().poll(&mut cx) {
            Poll::Ready(result) => return (result, yields),
            Poll::Pending => yields += 1,
        }
    }
}

async fn yield_once() {
    struct YieldOnce {
        yielded: bool,
    }

    impl Future for YieldOnce {
        type Output = ();

        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
            if self.yielded {
                Poll::Ready(())
            } else {
                self.yielded = true;
                cx.waker().wake_by_ref();
                Poll::Pending
            }
        }
    }

    YieldOnce { yielded: false }.await;
}

const fn noop_waker() -> Waker {
    const VTABLE: RawWakerVTable = RawWakerVTable::new(
        // Cloning just returns a new no-op raw waker
        |_| RAW,
        // `wake` does nothing
        |_| {},
        // `wake_by_ref` does nothing
        |_| {},
        // Dropping does nothing as we don't allocate anything
        |_| {},
    );
    const RAW: RawWaker = RawWaker::new(ptr::null(), &VTABLE);
    unsafe { Waker::from_raw(RAW) }
}