use std::collections::VecDeque;
use std::sync::{Arc, Condvar, Mutex};

pub struct Sender<T> {
    shared: Arc<Shared<T>>,
}

pub struct Receiver<T> {
    shared: Arc<Shared<T>>,
}

struct Shared<T> {
    queue: Mutex<VecDeque<T>>,
    available: Condvar,
    sender_alive: Mutex<bool>,
}

pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
    let shared = Arc::new(Shared {
        queue: Mutex::new(VecDeque::new()),
        available: Condvar::new(),
        sender_alive: Mutex::new(true),
    });
    (
        Sender { shared: shared.clone() },
        Receiver { shared },
    )
}

impl<T> Clone for Receiver<T> {
    fn clone(&self) -> Self {
        Receiver { shared: self.shared.clone() }
    }
}

impl<T> Sender<T> {
    pub fn send(&self, value: T) {
        // TODO: push to queue, notify one receiver.
        todo!()
    }
}

impl<T> Drop for Sender<T> {
    fn drop(&mut self) {
        // TODO: mark sender_alive = false, wake every blocked receiver.
        todo!()
    }
}

impl<T> Receiver<T> {
    pub fn recv(&self) -> Option<T> {
        // TODO: pop-or-wait loop. Return None only when queue is empty
        // AND sender_alive is false.
        todo!()
    }
}

use std::cell::UnsafeCell;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

const CAP: usize = 1024;

pub struct RingBuffer<T: Copy + Default> {
    buf: UnsafeCell<[T; CAP]>,
    head: AtomicUsize, // producer writes next; cell is valid if i < head
    tail: AtomicUsize, // consumer reads next; cell is free if i < tail
}

// SAFETY: head/tail indices partition the buffer; producer only touches
// indices in [tail, head), consumer only touches [tail, head) reads.
unsafe impl<T: Copy + Default + Send> Send for RingBuffer<T> {}
unsafe impl<T: Copy + Default + Send> Sync for RingBuffer<T> {}

pub struct Producer<T: Copy + Default> {
    inner: Arc<RingBuffer<T>>,
}

pub struct Consumer<T: Copy + Default> {
    inner: Arc<RingBuffer<T>>,
}

pub fn ring<T: Copy + Default>() -> (Producer<T>, Consumer<T>) {
    let buf = Arc::new(RingBuffer {
        buf: UnsafeCell::new([T::default(); CAP]),
        head: AtomicUsize::new(0),
        tail: AtomicUsize::new(0),
    });
    (Producer { inner: buf.clone() }, Consumer { inner: buf })
}

impl<T: Copy + Default> Producer<T> {
    pub fn try_push(&self, value: T) -> Result<(), T> {
        // TODO:
        //   1. Read head (Relaxed — we are the only writer).
        //   2. Read tail (Acquire — sync with consumer's last pop).
        //   3. If head - tail == CAP, queue is full: return Err(value).
        //   4. Write value into buf[head % CAP] (unsafe raw write).
        //   5. Publish by storing head + 1 with Release.
        todo!()
    }
}

impl<T: Copy + Default> Consumer<T> {
    pub fn try_pop(&self) -> Option<T> {
        // TODO:
        //   1. Read tail (Relaxed — we are the only writer).
        //   2. Read head (Acquire — sync with producer's last push).
        //   3. If head == tail, empty: return None.
        //   4. Read buf[tail % CAP] (unsafe raw read) into a local.
        //   5. Publish consumption by storing tail + 1 with Release.
        todo!()
    }
}