use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};
use std::time::Duration;

use async_trait::async_trait;
use btleplug::api::{bleuuid::uuid_from_u16, Central, Peripheral as _, ValueNotification, WriteType};
use btleplug::platform::{Adapter, Peripheral};
use futures::{Stream, StreamExt};
use tokio::sync::oneshot;
use uuid::Uuid;

use crate::ble::BleError;
use crate::commands::{encode_command, parse_control_result, Command, ControlPoint, ControlResult};
use crate::device::Device;
use crate::telemetry::{parse_csc, parse_hr, parse_indoor_bike_data, parse_power, CscAccumulator, Telemetry};

#[async_trait]
pub(crate) trait SensorSource: Send + Sync {
    async fn scan(&self, seconds: u64) -> Result<Vec<Device>, BleError>;

    /// Подключиться и вернуть поток распарсенных измерений.
    async fn stream(&self, device: &Device)
        -> Result<Pin<Box<dyn Stream<Item = Telemetry> + Send>>, BleError>;

    /// Отправить команду на управляющую точку устройства (ERG и т.п.).
    async fn command(&self, device: &Device, cmd: Command) -> Result<(), BleError>;

    /// Запросить контроль у FTMS-станка и дождаться подтверждения (0x80).
    async fn request_control(&self, device: &Device) -> Result<(), BleError>;

    /// Прочитать уровень заряда батареи (0..=100). Best-effort.
    async fn battery(&self, device: &Device) -> Result<u8, BleError>;
}

const HR_MEASUREMENT: Uuid = uuid_from_u16(0x2A37);
const CSC_MEASUREMENT: Uuid = uuid_from_u16(0x2A5B);
const POWER_MEASUREMENT: Uuid = uuid_from_u16(0x2A63);
const INDOOR_BIKE_DATA: Uuid = uuid_from_u16(0x2AD2);
const FITNESS_MACHINE_STATUS: Uuid = uuid_from_u16(0x2ADA);

// How long to wait for the trainer to confirm control (Control Point Response 0x80).
const CONTROL_CONFIRM_TIMEOUT: Duration = Duration::from_secs(3);
const CONTROL_POLL_INTERVAL: Duration = Duration::from_millis(50);

/// Реальный источник данных через btleplug.
pub(crate) struct BleSource {
    adapter: Adapter,
    /// Last control result (set by the notification router, awaited by `request_control`).
    control: Arc<Mutex<Option<ControlResult>>>,
}

impl BleSource {
    pub(crate) fn new(adapter: Adapter) -> Self {
        Self {
            adapter,
            control: Arc::new(Mutex::new(None)),
        }
    }

    async fn find_peripheral(&self, device: &Device) -> Result<Peripheral, BleError> {
        let peripherals = self
            .adapter
            .peripherals()
            .await
            .map_err(BleError::PeripheralsFailed)?;
        peripherals
            .into_iter()
            .find(|p| p.id().to_string() == device.id)
            .ok_or_else(|| BleError::DeviceNotFound(device.id.clone()))
    }
}

/// Stream wrapper that cancels the background notification router on drop, so a
/// reconnect does not leak the previous cycle's routing task.
struct CancellableStream {
    inner: tokio_stream::wrappers::UnboundedReceiverStream<Telemetry>,
    cancel: Option<oneshot::Sender<()>>,
}

impl Stream for CancellableStream {
    type Item = Telemetry;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Telemetry>> {
        Pin::new(&mut self.inner).poll_next(cx)
    }
}

impl Drop for CancellableStream {
    fn drop(&mut self) {
        if let Some(cancel) = self.cancel.take() {
            let _ = cancel.send(());
        }
    }
}

#[async_trait]
impl SensorSource for BleSource {
    async fn scan(&self, seconds: u64) -> Result<Vec<Device>, BleError> {
        crate::ble::scan_devices(&self.adapter, seconds).await
    }

    async fn stream(&self, device: &Device)
        -> Result<Pin<Box<dyn Stream<Item = Telemetry> + Send>>, BleError>
    {
        let peripheral = self.find_peripheral(device).await?;
        ensure_connected(&peripheral).await?;

        let targets = [
            HR_MEASUREMENT,
            CSC_MEASUREMENT,
            POWER_MEASUREMENT,
            INDOOR_BIKE_DATA,
            FITNESS_MACHINE_STATUS,
        ];
        for ch in peripheral.characteristics().iter() {
            if targets.contains(&ch.uuid) {
                // Unsubscribe first (best-effort) so a stale reconnect does not double-subscribe.
                let _ = peripheral.unsubscribe(ch).await;
                peripheral.subscribe(ch).await.map_err(BleError::SubscribeFailed)?;
            }
        }

        let notifications = peripheral
            .notifications()
            .await
            .map_err(BleError::NotificationsFailed)?;

        // Route notifications on a background task: telemetry -> mpsc, control result -> shared state.
        // This keeps the control-result flow concurrent with the telemetry consumer so that
        // `request_control` can await confirmation while telemetry is still being consumed.
        let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<Telemetry>();
        let control = self.control.clone();
        let (cancel_tx, cancel_rx) = oneshot::channel::<()>();

        tokio::spawn(async move {
            let mut notifications = notifications;
            let mut acc = CscAccumulator::new();
            let mut cancel_rx = cancel_rx;
            loop {
                tokio::select! {
                    n = notifications.next() => {
                        match n {
                            Some(n) => {
                                for t in parse_notification(n, &mut acc, &control) {
                                    let _ = tx.send(t);
                                }
                            }
                            None => break,
                        }
                    }
                    _ = &mut cancel_rx => break,
                }
            }
        });

        let stream: Pin<Box<dyn Stream<Item = Telemetry> + Send>> = Box::pin(CancellableStream {
            inner: tokio_stream::wrappers::UnboundedReceiverStream::new(rx),
            cancel: Some(cancel_tx),
        });
        Ok(stream)
    }

    async fn command(&self, device: &Device, cmd: Command) -> Result<(), BleError> {
        let peripheral = self.find_peripheral(device).await?;
        ensure_connected(&peripheral).await?;

        let (control_point, payload) = encode_command(cmd);
        let cp_uuid = uuid_from_u16(control_point.short_uuid());
        let ch = peripheral
            .characteristics()
            .into_iter()
            .find(|c| c.uuid == cp_uuid)
            .ok_or_else(|| BleError::DeviceNotFound(cp_uuid.to_string()))?;

        peripheral
            .write(&ch, &payload, WriteType::WithoutResponse)
            .await
            .map_err(BleError::WriteFailed)
    }

    async fn request_control(&self, device: &Device) -> Result<(), BleError> {
        let peripheral = self.find_peripheral(device).await?;
        ensure_connected(&peripheral).await?;

        let cp_uuid = uuid_from_u16(ControlPoint::Ftms.short_uuid());
        let ch = peripheral
            .characteristics()
            .into_iter()
            .find(|c| c.uuid == cp_uuid)
            .ok_or_else(|| BleError::DeviceNotFound(cp_uuid.to_string()))?;

        // Reset and send Request Control (opcode 0x00).
        *self.control.lock().unwrap() = None;
        let (_, payload) = encode_command(Command::FtmsRequestControl);
        peripheral
            .write(&ch, &payload, WriteType::WithoutResponse)
            .await
            .map_err(BleError::WriteFailed)?;

        // Wait for the Control Point Response (routed by the stream's notification task).
        let result = tokio::time::timeout(CONTROL_CONFIRM_TIMEOUT, async {
            loop {
                let current = *self.control.lock().unwrap();
                if let Some(r) = current {
                    return r;
                }
                tokio::time::sleep(CONTROL_POLL_INTERVAL).await;
            }
        })
        .await
        .map_err(|_| BleError::ControlTimeout)?;

        match result {
            ControlResult::Success => Ok(()),
            other => Err(BleError::ControlRejected(other)),
        }
    }

    async fn battery(&self, device: &Device) -> Result<u8, BleError> {
        let peripheral = self.find_peripheral(device).await?;
        ensure_connected(&peripheral).await?;

        let batt_uuid = uuid_from_u16(0x2A19);
        let ch = peripheral
            .characteristics()
            .into_iter()
            .find(|c| c.uuid == batt_uuid)
            .ok_or_else(|| BleError::DeviceNotFound("0x2A19".into()))?;

        let value = peripheral.read(&ch).await.map_err(BleError::ReadFailed)?;
        value
            .first()
            .copied()
            .filter(|p| *p <= 100)
            .ok_or_else(|| BleError::DeviceNotFound("уровень батареи".into()))
    }
}

async fn ensure_connected(peripheral: &Peripheral) -> Result<(), BleError> {
    if !peripheral.is_connected().await.unwrap_or(false) {
        peripheral.connect().await.map_err(BleError::ConnectFailed)?;
    }
    peripheral
        .discover_services()
        .await
        .map_err(BleError::DiscoverFailed)?;
    Ok(())
}

fn parse_notification(
    n: ValueNotification,
    acc: &mut CscAccumulator,
    control: &Arc<Mutex<Option<ControlResult>>>,
) -> Vec<Telemetry> {
    if n.uuid == HR_MEASUREMENT {
        parse_hr(&n.value).into_iter().collect()
    } else if n.uuid == CSC_MEASUREMENT {
        parse_csc(&n.value)
            .and_then(|raw| acc.push(raw))
            .map(|rpm| Telemetry::Cadence { rpm })
            .into_iter()
            .collect()
    } else if n.uuid == POWER_MEASUREMENT {
        parse_power(&n.value).into_iter().collect()
    } else if n.uuid == INDOOR_BIKE_DATA {
        parse_indoor_bike_data(&n.value)
    } else if n.uuid == FITNESS_MACHINE_STATUS {
        if let Some(result) = parse_control_result(&n.value) {
            *control.lock().unwrap() = Some(result);
        }
        Vec::new()
    } else {
        Vec::new()
    }
}