use std::time::Duration;

use eyre::Result;
use rand::Rng;
use tokio::time::{self, MissedTickBehavior};
use tonic::{Request, Response, Status};
use tracing::{Level, instrument};

use turtle::generated::{
    DAEMON_PROTOCOL_VERSION,
    control::{
        ForceSyncReply, ForceSyncRequest, PathsReply, PathsRequest, StatusReply, StatusRequest,
        control_server::{Control, ControlServer},
    },
};

use crate::{
    DAEMON_VERSION,
    aclient::{history::store::HistoryStore, record::sync, settings::Settings},
    daemon::DaemonHandle,
    events::DaemonEvent,
};

/// Sync state - tracks whether we're in normal operation or retrying after failure.
#[derive(Clone, Copy, PartialEq, Eq)]
enum SyncState {
    /// Normal operation. Periodic syncs only run if [`auto_sync`] is enabled.
    Idle,
    /// Retrying after a sync failure. Retries continue regardless of [`auto_sync`]
    /// until the sync succeeds.
    Retrying,
}

/// The Control gRPC service.
///
/// This service is used by external processes to inject events into the daemon.
/// It's not a component - it's part of the daemon's core infrastructure.
pub(crate) struct ControlService {
    handle: DaemonHandle,
    task_handle: tokio::task::JoinHandle<()>,
}

impl ControlService {
    /// Create a new control service with the given daemon handle.
    pub(crate) fn new(handle: DaemonHandle) -> Self {
        let task_handle = tokio::spawn(sync_loop(handle.clone()));

        Self {
            handle,
            task_handle,
        }
    }

    /// Get a tonic server for this service.
    pub(crate) fn into_server(self) -> ControlServer<Self> {
        ControlServer::new(self)
    }
}

#[tonic::async_trait]
impl Control for ControlService {
    #[instrument(skip_all, level = Level::INFO)]
    async fn paths(&self, _request: Request<PathsRequest>) -> Result<Response<PathsReply>, Status> {
        let settings = self.handle.settings().await;

        let config = Settings::get_config_path()
            .map_err(|e| Status::internal(format!("failed to get settings path: {e:?}")))?;

        let reply = PathsReply {
            config: config.to_string_lossy().to_string(),
            db: settings.db_path.clone(),
            socket: settings.daemon.socket_path.clone(),
        };

        Ok(Response::new(reply))
    }

    #[instrument(skip_all, level = Level::INFO)]
    async fn status(
        &self,
        _request: Request<StatusRequest>,
    ) -> Result<Response<StatusReply>, Status> {
        let reply = StatusReply {
            healthy: true,
            version: DAEMON_VERSION.to_owned(),
            pid: std::process::id(),
            protocol: DAEMON_PROTOCOL_VERSION,
        };

        Ok(Response::new(reply))
    }

    #[instrument(skip_all, level = Level::INFO)]
    async fn force_sync(
        &self,
        _request: Request<ForceSyncRequest>,
    ) -> Result<Response<ForceSyncReply>, Status> {
        let reply = ForceSyncReply { accepted: true };

        self.handle.emit(DaemonEvent::ForceSync);

        Ok(Response::new(reply))
    }
}

/// The main sync loop.
///
/// This runs in a spawned task and handles periodic sync as well as
/// force sync requests.
#[expect(clippy::significant_drop_tightening, reason = "false positive")]
async fn sync_loop(handle: DaemonHandle) {
    tracing::info!("sync loop starting");

    // Clone settings since we need them across await points
    let settings = handle.settings().await.clone();
    let host_id = match Settings::host_id().await {
        Ok(id) => id,
        Err(e) => {
            tracing::error!("failed to get host id, sync disabled: {e}");
            return;
        }
    };

    // Create the stores we need
    let encryption_key = *handle.encryption_key();
    let history_store = HistoryStore::new(handle.store().clone(), host_id, encryption_key);

    // Don't backoff by more than 30 mins (with a random jitter of up to 1 min)
    let max_interval: f64 = 60.0f64.mul_add(30.0, rand::thread_rng().gen_range(0.0..60.0));

    let mut ticker = time::interval(Duration::from_secs(settings.daemon.sync_frequency));

    // IMPORTANT: without this, if we miss ticks because a sync takes ages or is otherwise delayed,
    // we may end up running a lot of syncs in a hot loop.
    ticker.set_missed_tick_behavior(MissedTickBehavior::Skip);

    let mut sync_state = SyncState::Idle;

    let mut daemon_rx = handle.subscribe();
    loop {
        tokio::select! {
            _ = ticker.tick() => {
                let settings = handle.settings().await;

                // Skip periodic ticks if auto_sync is disabled AND we're not retrying
                // a previous failure. Retries must continue regardless of auto_sync.
                if !settings.sync.auto && sync_state == SyncState::Idle {
                    tracing::debug!("auto_sync disabled, skipping periodic sync tick");
                    continue;
                }

                sync_state = do_sync_tick(
                    &handle,
                    &history_store,
                    &mut ticker,
                    max_interval,
                    &settings,
                ).await;
            }
            cmd = daemon_rx.recv() => {
                match cmd {
                    Ok(DaemonEvent::ForceSync) => {
                        tracing::info!("executing force sync");
                        let settings = handle.settings().await;
                        sync_state = do_sync_tick(
                            &handle,
                            &history_store,
                            &mut ticker,
                            max_interval,
                            &settings,
                        ).await;
                    },
                    Ok(DaemonEvent::ShutdownRequested) | Err(_) => {
                        tracing::info!("sync loop stopping");
                        break;
                    },
                    _ => ()
                }
            }
        }
    }
}

/// Execute a single sync tick.
///
/// Returns the new sync state: `Idle` on success, `Retrying` on failure.
async fn do_sync_tick(
    handle: &DaemonHandle,
    history_store: &HistoryStore,
    ticker: &mut time::Interval,
    max_interval: f64,
    settings: &Settings,
) -> SyncState {
    tracing::info!("sync tick");

    // Check if logged in
    let logged_in = match settings.sync.have_sync_user() {
        Ok(v) => v,
        Err(e) => {
            tracing::warn!("failed to check login status, skipping sync tick: {e}");
            return SyncState::Idle;
        }
    };

    if !logged_in {
        tracing::debug!("not logged in, skipping sync tick");
        return SyncState::Idle;
    }

    // Perform the sync
    let res = sync::sync(settings, handle.store(), handle.encryption_key()).await;

    match res {
        Err(e) => {
            tracing::error!("sync tick failed with {e}");

            handle.emit(DaemonEvent::SyncFailed {
                error: e.to_string(),
            });

            // Exponential backoff
            let mut rng = rand::thread_rng();
            let mut new_interval = ticker.period().as_secs_f64() * rng.gen_range(2.0..2.2);

            if new_interval > max_interval {
                new_interval = max_interval;
            }

            *ticker = time::interval_at(
                time::Instant::now() + Duration::from_secs(new_interval as u64),
                Duration::from_secs(new_interval as u64),
            );
            ticker.reset_after(Duration::from_secs(new_interval as u64));
            ticker.set_missed_tick_behavior(MissedTickBehavior::Skip);

            tracing::error!("backing off, next sync tick in {new_interval}");

            SyncState::Retrying
        }
        Ok((uploaded_count, downloaded_records)) => {
            tracing::info!(
                uploaded = uploaded_count,
                downloaded = downloaded_records.len(),
                "sync complete"
            );

            // Build history from downloaded records
            if let Err(e) = history_store
                .incremental_build(handle.history_db(), &downloaded_records)
                .await
            {
                tracing::error!("failed to build history from downloaded records: {e}");
            }

            // Emit sync completed event
            handle.emit(DaemonEvent::SyncCompleted {
                uploaded: uploaded_count as usize,
                downloaded: downloaded_records.len(),
            });

            // Reset backoff on success
            if ticker.period().as_secs() != settings.daemon.sync_frequency {
                *ticker = time::interval_at(
                    time::Instant::now() + Duration::from_secs(settings.daemon.sync_frequency),
                    Duration::from_secs(settings.daemon.sync_frequency),
                );
                ticker.set_missed_tick_behavior(MissedTickBehavior::Skip);
            }

            // Store sync time
            if let Err(e) = Settings::save_sync_time().await {
                tracing::error!("failed to save sync time: {e}");
            }

            SyncState::Idle
        }
    }
}