use std::{
    collections::HashMap,
    net::{IpAddr, SocketAddr},
    sync::Arc,
};

use jsonrpsee::{
    RpcModule,
    server::{ServerBuilder, ServerHandle},
    types::error::ErrorObjectOwned,
};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};

use crate::{
    models::{Actor, Context, Flow, Job, Message, Runner, ScriptType},
    storage::RedisDriver,
    time::current_timestamp,
};

pub struct AppState {
    pub redis: RedisDriver,
}

impl AppState {
    pub fn new(redis: RedisDriver) -> Self {
        Self { redis }
    }
}

// -----------------------------
// Error helpers
// -----------------------------

fn invalid_params_err<E: std::fmt::Display>(e: E) -> ErrorObjectOwned {
    ErrorObjectOwned::owned(-32602, "Invalid params", Some(Value::String(e.to_string())))
}

fn storage_err(e: Box<dyn std::error::Error + Send + Sync>) -> ErrorObjectOwned {
    let msg = e.to_string();
    if msg.contains("Key not found") {
        ErrorObjectOwned::owned(-32001, "Not Found", Some(Value::String(msg)))
    } else {
        ErrorObjectOwned::owned(-32010, "Storage Error", Some(Value::String(msg)))
    }
}

// -----------------------------
// Local enums for DTOs (to keep quirks isolated)
// -----------------------------

#[derive(Debug, Deserialize, Serialize, Clone, Copy)]
#[serde(rename_all = "PascalCase")]
pub enum MessageFormatTypeDto {
    Html,
    Text,
    Md,
}

// -----------------------------
// Create DTOs and Param wrappers
// -----------------------------

#[derive(Debug, Deserialize)]
pub struct ActorCreate {
    pub id: u32,
    pub pubkey: String,
    pub address: Vec<IpAddr>,
}
impl ActorCreate {
    pub fn into_domain(self) -> Result<Actor, String> {
        let ts = current_timestamp();
        let v = json!({
            "id": self.id,
            "pubkey": self.pubkey,
            "address": self.address,
            "created_at": ts,
            "updated_at": ts,
        });
        serde_json::from_value(v).map_err(|e| e.to_string())
    }
}

#[derive(Debug, Deserialize)]
pub struct ContextCreate {
    pub id: u32,
    pub admins: Vec<u32>,
    pub readers: Vec<u32>,
    pub executors: Vec<u32>,
}
impl ContextCreate {
    pub fn into_domain(self) -> Result<Context, String> {
        let ts = current_timestamp();
        // Note: keep current code quirk: "upddated_at"
        let mut v = serde_json::Map::new();
        v.insert("id".to_string(), Value::from(self.id));
        v.insert(
            "admins".to_string(),
            serde_json::to_value(self.admins).unwrap(),
        );
        v.insert(
            "readers".to_string(),
            serde_json::to_value(self.readers).unwrap(),
        );
        v.insert(
            "executors".to_string(),
            serde_json::to_value(self.executors).unwrap(),
        );
        v.insert("created_at".to_string(), Value::from(ts));
        v.insert("upddated_at".to_string(), Value::from(ts));
        serde_json::from_value(Value::Object(v)).map_err(|e| e.to_string())
    }
}

#[derive(Debug, Deserialize)]
pub struct RunnerCreate {
    pub id: u32,
    pub pubkey: String,
    pub address: IpAddr,
    pub topic: String,
    pub local: bool,
}
impl RunnerCreate {
    pub fn into_domain(self) -> Result<Runner, String> {
        let ts = current_timestamp();
        // Note: keep current code quirk: "crated_at"
        let v = json!({
            "id": self.id,
            "pubkey": self.pubkey,
            "address": self.address,
            "topic": self.topic,
            "local": self.local,
            "crated_at": ts,
            "updated_at": ts,
        });
        serde_json::from_value(v).map_err(|e| e.to_string())
    }
}

#[derive(Debug, Deserialize)]
pub struct FlowCreate {
    pub id: u32,
    pub caller_id: u32,
    pub context_id: u32,
    pub jobs: Vec<u32>,
    pub env_vars: HashMap<String, String>,
    #[serde(default)]
    pub result: Option<HashMap<String, String>>,
}
impl FlowCreate {
    pub fn into_domain(self) -> Result<Flow, String> {
        let ts = current_timestamp();
        let v = json!({
            "id": self.id,
            "caller_id": self.caller_id,
            "context_id": self.context_id,
            "jobs": self.jobs,
            "env_vars": self.env_vars,
            "result": self.result.unwrap_or_default(),
            "created_at": ts,
            "updated_at": ts,
            "status": "Dispatched",
        });
        serde_json::from_value(v).map_err(|e| e.to_string())
    }
}

#[derive(Debug, Deserialize)]
pub struct JobCreate {
    pub id: u32,
    pub caller_id: u32,
    pub context_id: u32,
    pub script: String,
    pub script_type: ScriptType,
    pub timeout: u32,
    pub retries: u8,
    pub env_vars: HashMap<String, String>,
    #[serde(default)]
    pub result: Option<HashMap<String, String>>,
    pub prerequisites: Vec<String>,
    pub depends: Vec<u32>,
}
impl JobCreate {
    pub fn into_domain(self) -> Result<Job, String> {
        let ts = current_timestamp();
        let v = json!({
            "id": self.id,
            "caller_id": self.caller_id,
            "context_id": self.context_id,
            "script": self.script,
            "script_type": self.script_type,
            "timeout": self.timeout,
            "retries": self.retries,
            "env_vars": self.env_vars,
            "result": self.result.unwrap_or_default(),
            "prerequisites": self.prerequisites,
            "depends": self.depends,
            "created_at": ts,
            "updated_at": ts,
            "status": "Dispatched",
        });
        serde_json::from_value(v).map_err(|e| e.to_string())
    }
}

#[derive(Debug, Deserialize)]
pub struct MessageCreate {
    pub id: u32,
    pub caller_id: u32,
    pub context_id: u32,
    pub message: String,
    // Note: model uses ScriptType for message_type (keep as-is)
    pub message_type: ScriptType,
    pub message_format_type: MessageFormatTypeDto,
    pub timeout: u32,
    pub timeout_ack: u32,
    pub timeout_result: u32,
    pub job: Vec<JobCreate>,
    #[serde(default)]
    pub logs: Option<Vec<String>>,
}
impl MessageCreate {
    pub fn into_domain(self) -> Result<Message, String> {
        let ts = current_timestamp();
        let jobs: Result<Vec<Value>, String> = self
            .job
            .into_iter()
            .map(|j| {
                let jd: Job = j.into_domain()?;
                serde_json::to_value(jd).map_err(|e| e.to_string())
            })
            .collect();
        let v = json!({
            "id": self.id,
            "caller_id": self.caller_id,
            "context_id": self.context_id,
            "message": self.message,
            "message_type": self.message_type,
            "message_format_type": self.message_format_type, // "Html" | "Text" | "Md"
            "timeout": self.timeout,
            "timeout_ack": self.timeout_ack,
            "timeout_result": self.timeout_result,
            "job": jobs?,
            "logs": self.logs.unwrap_or_default(),
            "created_at": ts,
            "updated_at": ts,
            "status": "Dispatched",
        });
        serde_json::from_value(v).map_err(|e| e.to_string())
    }
}

#[derive(Debug, Deserialize)]
pub struct ActorCreateParams {
    pub context_id: u32,
    pub actor: ActorCreate,
}
#[derive(Debug, Deserialize)]
pub struct ActorLoadParams {
    pub context_id: u32,
    pub id: u32,
}

#[derive(Debug, Deserialize)]
pub struct ContextCreateParams {
    pub context: ContextCreate,
}
#[derive(Debug, Deserialize)]
pub struct ContextLoadParams {
    pub id: u32,
}

#[derive(Debug, Deserialize)]
pub struct RunnerCreateParams {
    pub context_id: u32,
    pub runner: RunnerCreate,
}
#[derive(Debug, Deserialize)]
pub struct RunnerLoadParams {
    pub context_id: u32,
    pub id: u32,
}

#[derive(Debug, Deserialize)]
pub struct FlowCreateParams {
    pub context_id: u32,
    pub flow: FlowCreate,
}
#[derive(Debug, Deserialize)]
pub struct FlowLoadParams {
    pub context_id: u32,
    pub id: u32,
}

#[derive(Debug, Deserialize)]
pub struct JobCreateParams {
    pub context_id: u32,
    pub job: JobCreate,
}
#[derive(Debug, Deserialize)]
pub struct JobLoadParams {
    pub context_id: u32,
    pub caller_id: u32,
    pub id: u32,
}

#[derive(Debug, Deserialize)]
pub struct MessageCreateParams {
    pub context_id: u32,
    pub message: MessageCreate,
}
#[derive(Debug, Deserialize)]
pub struct MessageLoadParams {
    pub context_id: u32,
    pub caller_id: u32,
    pub id: u32,
}

// -----------------------------
// Rpc module builder (manual registration)
// -----------------------------

pub fn build_module(state: Arc<AppState>) -> RpcModule<()> {
    let mut module: RpcModule<()> = RpcModule::new(());

    // Actor
    {
        let state = state.clone();
        module
            .register_async_method("actor.create", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: ActorCreateParams = params.parse().map_err(invalid_params_err)?;
                    let actor = p.actor.into_domain().map_err(invalid_params_err)?;
                    state
                        .redis
                        .save_actor(p.context_id, &actor)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(actor).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register actor.create");
    }
    {
        let state = state.clone();
        module
            .register_async_method("actor.load", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: ActorLoadParams = params.parse().map_err(invalid_params_err)?;
                    let actor = state
                        .redis
                        .load_actor(p.context_id, p.id)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(actor).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register actor.load");
    }

    // Context
    {
        let state = state.clone();
        module
            .register_async_method("context.create", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: ContextCreateParams = params.parse().map_err(invalid_params_err)?;
                    let ctx = p.context.into_domain().map_err(invalid_params_err)?;
                    state.redis.save_context(&ctx).await.map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(ctx).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register context.create");
    }
    {
        let state = state.clone();
        module
            .register_async_method("context.load", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: ContextLoadParams = params.parse().map_err(invalid_params_err)?;
                    let ctx = state.redis.load_context(p.id).await.map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(ctx).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register context.load");
    }

    // Runner
    {
        let state = state.clone();
        module
            .register_async_method("runner.create", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: RunnerCreateParams = params.parse().map_err(invalid_params_err)?;
                    let runner = p.runner.into_domain().map_err(invalid_params_err)?;
                    state
                        .redis
                        .save_runner(p.context_id, &runner)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(runner).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register runner.create");
    }
    {
        let state = state.clone();
        module
            .register_async_method("runner.load", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: RunnerLoadParams = params.parse().map_err(invalid_params_err)?;
                    let runner = state
                        .redis
                        .load_runner(p.context_id, p.id)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(runner).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register runner.load");
    }

    // Flow
    {
        let state = state.clone();
        module
            .register_async_method("flow.create", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: FlowCreateParams = params.parse().map_err(invalid_params_err)?;
                    let flow = p.flow.into_domain().map_err(invalid_params_err)?;
                    state
                        .redis
                        .save_flow(p.context_id, &flow)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(flow).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register flow.create");
    }
    {
        let state = state.clone();
        module
            .register_async_method("flow.load", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: FlowLoadParams = params.parse().map_err(invalid_params_err)?;
                    let flow = state
                        .redis
                        .load_flow(p.context_id, p.id)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(flow).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register flow.load");
    }

    // Job
    {
        let state = state.clone();
        module
            .register_async_method("job.create", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: JobCreateParams = params.parse().map_err(invalid_params_err)?;
                    let job = p.job.into_domain().map_err(invalid_params_err)?;
                    state
                        .redis
                        .save_job(p.context_id, &job)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(job).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register job.create");
    }
    {
        let state = state.clone();
        module
            .register_async_method("job.load", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: JobLoadParams = params.parse().map_err(invalid_params_err)?;
                    let job = state
                        .redis
                        .load_job(p.context_id, p.caller_id, p.id)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(job).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register job.load");
    }

    // Message
    {
        let state = state.clone();
        module
            .register_async_method("message.create", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: MessageCreateParams = params.parse().map_err(invalid_params_err)?;
                    let message = p.message.into_domain().map_err(invalid_params_err)?;
                    state
                        .redis
                        .save_message(p.context_id, &message)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(message).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register message.create");
    }
    {
        let state = state;
        module
            .register_async_method("message.load", move |params, _caller, _ctx| {
                let state = state.clone();
                async move {
                    let p: MessageLoadParams = params.parse().map_err(invalid_params_err)?;
                    let msg = state
                        .redis
                        .load_message(p.context_id, p.caller_id, p.id)
                        .await
                        .map_err(storage_err)?;
                    {
                        let out: serde_json::Value =
                            serde_json::to_value(msg).map_err(invalid_params_err)?;
                        Ok::<serde_json::Value, ErrorObjectOwned>(out)
                    }
                }
            })
            .expect("register message.load");
    }

    module
}

// -----------------------------
// Server runners (HTTP/WS on separate listeners)
// -----------------------------

pub async fn start_http<C>(
    addr: SocketAddr,
    module: RpcModule<C>,
) -> Result<ServerHandle, Box<dyn std::error::Error + Send + Sync>> {
    let server = ServerBuilder::default().build(addr).await?;
    let handle = server.start(module);
    Ok(handle)
}

pub async fn start_ws<C>(
    addr: SocketAddr,
    module: RpcModule<C>,
) -> Result<ServerHandle, Box<dyn std::error::Error + Send + Sync>> {
    // jsonrpsee server supports both HTTP and WS; using a second listener gives us a dedicated WS port.
    let server = ServerBuilder::default().build(addr).await?;
    let handle = server.start(module);
    Ok(handle)
}