use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::Value;

pub use crate::database::{SortField, WhereClause, WhereCondition};

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
#[serde(rename_all = "camelCase")]
pub struct Record {
    pub uri: String,
    pub cid: String,
    pub did: String,
    pub collection: String,
    pub json: Value,
    pub indexed_at: DateTime<Utc>,
    pub slice_uri: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct IndexedRecord {
    pub uri: String,
    pub cid: String,
    pub did: String,
    pub collection: String,
    pub value: Value,
    pub indexed_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BulkSyncParams {
    pub collections: Option<Vec<String>>,
    pub external_collections: Option<Vec<String>>,
    pub repos: Option<Vec<String>>,
    pub limit_per_repo: Option<i32>,
    pub skip_validation: Option<bool>,
    pub max_repos: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
#[serde(rename_all = "camelCase")]
pub struct Actor {
    pub did: String,
    pub handle: Option<String>,
    pub slice_uri: String,
    pub indexed_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CollectionStats {
    pub collection: String,
    pub record_count: i64,
    pub unique_actors: i64,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SliceRecordsParams {
    pub slice: String,
    pub limit: Option<i32>,
    pub cursor: Option<String>,
    #[serde(rename = "where")]
    pub where_clause: Option<WhereClause>,
    pub sort_by: Option<Vec<SortField>>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SliceRecordsOutput {
    pub records: Vec<IndexedRecord>,
    pub cursor: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
#[serde(rename_all = "camelCase")]
pub struct OAuthClient {
    pub id: i32,
    pub slice_uri: String,
    pub client_id: String,
    pub registration_access_token: Option<String>,
    pub created_at: DateTime<Utc>,
    pub created_by_did: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SparklinePoint {
    pub timestamp: String,
    pub count: i64,
}

/// Date interval for date truncation in aggregations
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum DateInterval {
    Second,
    Minute,
    Hour,
    Day,
    Week,
    Month,
    Quarter,
    Year,
}

impl DateInterval {
    /// Convert to PostgreSQL date_trunc() interval string
    pub fn to_pg_interval(&self) -> &'static str {
        match self {
            DateInterval::Second => "second",
            DateInterval::Minute => "minute",
            DateInterval::Hour => "hour",
            DateInterval::Day => "day",
            DateInterval::Week => "week",
            DateInterval::Month => "month",
            DateInterval::Quarter => "quarter",
            DateInterval::Year => "year",
        }
    }
}

/// Group by field specification for aggregations
#[derive(Debug, Clone)]
pub enum GroupByField {
    /// Simple field name
    Simple(String),
    /// Date-truncated field
    Truncated {
        field: String,
        interval: DateInterval,
    },
}

impl GroupByField {
    /// Get the field name
    pub fn field_name(&self) -> &str {
        match self {
            GroupByField::Simple(name) => name,
            GroupByField::Truncated { field, .. } => field,
        }
    }
}