#![allow(unused)]

use chrono::prelude::*;
use ipld_core::cid::Cid;
use serde::Deserialize;
use serde_bytes::ByteBuf;

#[derive(Debug)]
pub enum FirehoseOutput {
    Close,
    Event(Box<FirehoseEvent>),
    Error(AtpEventStreamError),
    Continue,
}

#[derive(Debug, Deserialize)]
pub struct AtpEventStreamHeader {
    pub op: i32,
    pub t: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct AtpEventStreamError {
    pub error: String,
    pub message: Option<String>,
}

#[derive(Debug)]
pub enum FirehoseEvent {
    Identity(AtpIdentityEvent),
    Account(AtpAccountEvent),
    Commit(AtpCommitEvent),
    Label(AtpLabelEvent),
    Sync(AtpSyncEvent),
}

#[derive(Debug, Deserialize)]
pub struct AtpIdentityEvent {
    pub seq: u64,
    pub did: String,
    pub time: DateTime<Utc>,
    pub handle: Option<String>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum AtpAccountStatus {
    Takendown,
    Suspended,
    Deleted,
    Deactivated,
    Throttled,
    Desynchronized,
}

impl AtpAccountStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            AtpAccountStatus::Takendown => "takendown",
            AtpAccountStatus::Suspended => "suspended",
            AtpAccountStatus::Deleted => "deleted",
            AtpAccountStatus::Deactivated => "deactivated",
            AtpAccountStatus::Throttled => "throttled",
            AtpAccountStatus::Desynchronized => "desynchronized",
        }
    }
}

impl From<AtpAccountStatus> for parakeet_db::types::ActorStatus {
    fn from(value: AtpAccountStatus) -> Self {
        match value {
            AtpAccountStatus::Takendown => parakeet_db::types::ActorStatus::Takendown,
            AtpAccountStatus::Suspended => parakeet_db::types::ActorStatus::Suspended,
            AtpAccountStatus::Deleted => parakeet_db::types::ActorStatus::Deleted,
            AtpAccountStatus::Deactivated => parakeet_db::types::ActorStatus::Deactivated,
            AtpAccountStatus::Throttled | AtpAccountStatus::Desynchronized => {
                parakeet_db::types::ActorStatus::Active
            }
        }
    }
}

#[derive(Debug, Deserialize)]
pub struct AtpAccountEvent {
    pub seq: u64,
    pub did: String,
    pub time: DateTime<Utc>,
    pub active: bool,
    pub status: Option<AtpAccountStatus>,
}

#[derive(Debug, Deserialize)]
pub struct AtpCommitEvent {
    pub seq: u64,
    pub repo: String,
    pub time: DateTime<Utc>,
    pub rev: String,
    pub since: Option<String>,
    pub commit: Cid,
    #[serde(rename = "tooBig")]
    #[deprecated]
    pub too_big: bool,
    #[serde(default)]
    pub blocks: ByteBuf,
    #[serde(default)]
    pub ops: Vec<CommitOp>,
    #[serde(default)]
    #[deprecated]
    pub blobs: Vec<Cid>,
    #[serde(rename = "prevData")]
    pub prev_data: Option<Cid>,
}

#[derive(Debug, Deserialize)]
pub struct CommitOp {
    pub action: String,
    pub cid: Option<Cid>,
    pub prev: Option<Cid>,
    pub path: String,
}

#[derive(Debug, Deserialize)]
pub struct AtpLabel {
    pub ver: i32,
    pub src: String,
    pub uri: String,
    pub cid: Option<String>,
    pub val: String,
    pub neg: Option<bool>,
    pub cts: DateTime<Utc>,
    pub exp: Option<DateTime<Utc>>,
    pub sig: Option<ByteBuf>,
}

#[derive(Debug, Deserialize)]
pub struct AtpLabelEvent {
    pub seq: u64,
    pub labels: Vec<AtpLabel>,
}

#[derive(Debug, Deserialize)]
pub struct AtpSyncEvent {
    pub seq: u64,
    pub did: String,
    pub time: DateTime<Utc>,
    pub rev: String,
    #[serde(default)]
    pub blocks: ByteBuf,
}