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

// ── Job Type ────────────────────────────────────────────────────────────

/// Discriminator for the kind of work a job performs.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum JobType {
    MsuiteSubmit,
    MsuiteMerge,
    MsuiteDeploy,
    RevalidateQueuedChangeset,
    ReleaseAssemble,
    DeployRelease,
    RuntimeProfileDriftCheck,
    TempEnvProvision,
    TempEnvExpire,
}

// ── Job State ───────────────────────────────────────────────────────────

/// Lifecycle states for an async job.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum JobState {
    Queued,
    Running,
    Succeeded,
    Failed,
    Canceled,
}

impl JobState {
    /// Returns `true` for terminal states that will never transition again.
    pub fn is_terminal(&self) -> bool {
        matches!(self, Self::Succeeded | Self::Failed | Self::Canceled)
    }
}

// ── Job ─────────────────────────────────────────────────────────────────

/// A unit of asynchronous work tracked in MongoDB.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Job {
    /// Unique identifier (MongoDB ObjectId hex).
    pub id: String,

    /// App this job belongs to.
    pub app_id: String,

    /// What kind of work this job performs.
    pub job_type: JobType,

    /// Current lifecycle state.
    pub state: JobState,

    /// The domain entity type this job acts on (e.g. "changeset", "release",
    /// "deployment", "temp_environment").
    pub entity_type: String,

    /// The domain entity id this job acts on.
    pub entity_id: String,

    /// Opaque input payload for the worker (contents vary by job_type).
    pub payload: serde_json::Value,

    /// Terminal result payload set by the worker on success.
    pub result: Option<serde_json::Value>,

    /// Human-readable error message set on failure.
    pub error_message: Option<String>,

    /// How many times this job has been attempted so far.
    pub retry_count: u32,

    /// Maximum retries before the job stays Failed permanently.
    pub max_retries: u32,

    /// Maximum wall-clock time (ms) before the runner cancels the job.
    pub timeout_ms: u64,

    /// When the job was created (enqueued).
    pub created_at: DateTime<Utc>,

    /// When the runner picked up the job (set to Running).
    pub started_at: Option<DateTime<Utc>>,

    /// When the job reached a terminal state.
    pub completed_at: Option<DateTime<Utc>>,
}

// ── Log Level ───────────────────────────────────────────────────────────

/// Severity level for structured job log entries.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LogLevel {
    Info,
    Warn,
    Error,
}

// ── Job Log ─────────────────────────────────────────────────────────────

/// A single structured log line emitted by a worker during execution.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JobLog {
    /// Unique identifier (MongoDB ObjectId hex).
    pub id: String,

    /// The job this log belongs to.
    pub job_id: String,

    /// Severity level.
    pub level: LogLevel,

    /// Human-readable log message.
    pub message: String,

    /// Optional structured data attached to the log entry.
    pub data: Option<serde_json::Value>,

    /// When the log was written.
    pub timestamp: DateTime<Utc>,
}

use async_trait::async_trait;

use conman_core::{Job, ConmanError};

// ── Job Worker Trait ────────────────────────────────────────────────────

/// Implemented by each job type to perform the actual work.
///
/// Workers receive an immutable reference to the Job (including payload) and
/// return a result payload on success. Workers write structured logs during
/// execution via the `JobLogger` passed at construction time.
#[async_trait]
pub trait JobWorker: Send + Sync {
    /// Execute the job's work. On success, return a JSON result payload that
    /// will be persisted on the Job document. On failure, return a
    /// `ConmanError` whose message becomes the job's `error_message`.
    async fn execute(&self, job: &Job) -> Result<serde_json::Value, ConmanError>;
}

// ── Job Logger ──────────────────────────────────────────────────────────

/// Handle passed to workers so they can emit structured log entries that are
/// persisted to the `job_logs` collection in real time.
#[derive(Clone)]
pub struct JobLogger {
    job_id: String,
    log_repo: JobLogRepo,
}

impl JobLogger {
    pub fn new(job_id: String, log_repo: JobLogRepo) -> Self {
        Self { job_id, log_repo }
    }

    pub async fn info(&self, message: &str, data: Option<serde_json::Value>) {
        self.write(LogLevel::Info, message, data).await;
    }

    pub async fn warn(&self, message: &str, data: Option<serde_json::Value>) {
        self.write(LogLevel::Warn, message, data).await;
    }

    pub async fn error(&self, message: &str, data: Option<serde_json::Value>) {
        self.write(LogLevel::Error, message, data).await;
    }

    /// Fire-and-forget write. Errors are traced but never propagated.
    async fn write(&self, level: LogLevel, message: &str, data: Option<serde_json::Value>) {
        let log = JobLog {
            id: ObjectId::new().to_hex(),
            job_id: self.job_id.clone(),
            level,
            message: message.to_string(),
            data,
            timestamp: Utc::now(),
        };
        if let Err(e) = self.log_repo.insert(&log).await {
            tracing::warn!(job_id = %self.job_id, error = %e, "failed to write job log");
        }
    }
}

// ── Job Runner ──────────────────────────────────────────────────────────

/// The background polling loop that claims Queued jobs and dispatches them to
/// the appropriate `JobWorker` implementation.
pub struct JobRunner {
    /// MongoDB repository for the `jobs` collection.
    job_repo: JobRepo,

    /// MongoDB repository for the `job_logs` collection.
    log_repo: JobLogRepo,

    /// Registry mapping JobType -> Box<dyn JobWorker>.
    workers: HashMap<JobType, Box<dyn JobWorker>>,

    /// How often (ms) the runner polls for new work when idle.
    poll_interval_ms: u64,

    /// Shutdown signal receiver.
    shutdown: tokio::sync::watch::Receiver<bool>,
}

impl JobRunner {
    pub fn new(
        job_repo: JobRepo,
        log_repo: JobLogRepo,
        workers: HashMap<JobType, Box<dyn JobWorker>>,
        poll_interval_ms: u64,
        shutdown: tokio::sync::watch::Receiver<bool>,
    ) -> Self {
        Self { job_repo, log_repo, workers, poll_interval_ms, shutdown }
    }

    /// Main loop: poll for the oldest Queued job, claim it atomically, execute
    /// the matching worker, and transition to Succeeded or Failed.
    pub async fn run(&self) {
        loop {
            // Check for graceful shutdown signal
            if *self.shutdown.borrow() {
                tracing::info!("job runner shutting down");
                break;
            }

            // Attempt to claim and execute one job
            match self.poll_and_execute().await {
                Ok(true) => {
                    // Executed a job — immediately poll for the next one
                    continue;
                }
                Ok(false) => {
                    // No jobs available — sleep before next poll
                }
                Err(e) => {
                    tracing::error!(error = %e, "job runner poll error");
                }
            }

            tokio::time::sleep(
                std::time::Duration::from_millis(self.poll_interval_ms)
            ).await;
        }
    }

    /// Claim the oldest Queued job via atomic findOneAndUpdate, execute the
    /// worker, and transition the job to its terminal state.
    /// Returns `Ok(true)` if a job was processed, `Ok(false)` if none available.
    async fn poll_and_execute(&self) -> Result<bool, ConmanError> {
        // Atomic claim: state=Queued -> Running, set started_at
        let Some(mut job) = self.job_repo.claim_next().await? else {
            return Ok(false);
        };

        let logger = JobLogger::new(job.id.clone(), self.log_repo.clone());

        let Some(worker) = self.workers.get(&job.job_type) else {
            // No registered worker — mark failed
            self.job_repo.mark_failed(
                &job.id,
                &format!("no worker registered for job type {:?}", job.job_type),
            ).await?;
            return Ok(true);
        };

        // Execute with timeout
        let timeout = std::time::Duration::from_millis(job.timeout_ms);
        let result = tokio::time::timeout(timeout, worker.execute(&job)).await;

        match result {
            // Worker completed within timeout
            Ok(Ok(result_payload)) => {
                self.job_repo.mark_succeeded(&job.id, result_payload).await?;
            }
            // Worker returned an error
            Ok(Err(e)) => {
                self.handle_failure(&mut job, &e.to_string()).await?;
            }
            // Timeout elapsed
            Err(_) => {
                self.job_repo.mark_canceled(&job.id, "timeout exceeded").await?;
                logger.error(
                    &format!("job timed out after {}ms", job.timeout_ms),
                    None,
                ).await;
            }
        }

        Ok(true)
    }

    /// On failure: if retries remain, re-queue with incremented count.
    /// Otherwise stay Failed.
    async fn handle_failure(&self, job: &mut Job, error_msg: &str) -> Result<(), ConmanError> {
        if job.retry_count < job.max_retries {
            self.job_repo.requeue_for_retry(&job.id, job.retry_count + 1).await?;
        } else {
            self.job_repo.mark_failed(&job.id, error_msg).await?;
        }
        Ok(())
    }
}

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

use conman_core::{JobType, JobState, LogLevel};

// ── API Response DTOs ───────────────────────────────────────────────────

/// GET /api/apps/:appId/jobs/:jobId response body.
#[derive(Debug, Serialize)]
pub struct JobResponse {
    pub id: String,
    pub app_id: String,
    pub job_type: JobType,
    pub state: JobState,
    pub entity_type: String,
    pub entity_id: String,
    pub payload: serde_json::Value,
    pub result: Option<serde_json::Value>,
    pub error_message: Option<String>,
    pub retry_count: u32,
    pub max_retries: u32,
    pub timeout_ms: u64,
    pub created_at: DateTime<Utc>,
    pub started_at: Option<DateTime<Utc>>,
    pub completed_at: Option<DateTime<Utc>>,
}

/// Individual log entry within a job response or log listing.
#[derive(Debug, Serialize)]
pub struct JobLogResponse {
    pub id: String,
    pub job_id: String,
    pub level: LogLevel,
    pub message: String,
    pub data: Option<serde_json::Value>,
    pub timestamp: DateTime<Utc>,
}

/// Query parameters for GET /api/apps/:appId/jobs
#[derive(Debug, Deserialize)]
pub struct ListJobsQuery {
    #[serde(default = "default_page")]
    pub page: u64,

    #[serde(default = "default_limit")]
    pub limit: u64,

    /// Filter by job type (optional).
    #[serde(rename = "type")]
    pub job_type: Option<JobType>,

    /// Filter by job state (optional).
    pub state: Option<JobState>,
}

fn default_page() -> u64 { 1 }
fn default_limit() -> u64 { 20 }

// Polling: claim the oldest Queued job efficiently
{ "state": 1, "created_at": 1 }

// Look up jobs for a specific entity (e.g. all jobs for a changeset)
{ "app_id": 1, "entity_type": 1, "entity_id": 1 }

// Gate hook: find the latest job of a given type+state for an entity
{ "app_id": 1, "job_type": 1, "state": 1 }

{
  "_id": ObjectId("665a1b2c3d4e5f6a7b8c9d0e"),
  "app_id": ObjectId("665a0001aabbccddee000001"),
  "job_type": "msuite_submit",
  "state": "queued",
  "entity_type": "changeset",
  "entity_id": ObjectId("665a0002aabbccddee000002"),
  "payload": {
    "changeset_id": "665a0002aabbccddee000002",
    "head_sha": "abc123def456",
    "base_sha": "789012fed345"
  },
  "result": null,
  "error_message": null,
  "retry_count": 0,
  "max_retries": 3,
  "timeout_ms": 300000,
  "created_at": ISODate("2025-06-01T12:00:00Z"),
  "started_at": null,
  "completed_at": null
}

// Fetch logs for a job in chronological order
{ "job_id": 1, "timestamp": 1 }

{
  "_id": ObjectId("665a1c001122334455667788"),
  "job_id": ObjectId("665a1b2c3d4e5f6a7b8c9d0e"),
  "level": "info",
  "message": "msuite test suite started",
  "data": {
    "suite": "config_validation",
    "test_count": 42
  },
  "timestamp": ISODate("2025-06-01T12:00:05Z")
}

{
  "data": {
    "id": "665a1b2c3d4e5f6a7b8c9d0e",
    "app_id": "665a0001aabbccddee000001",
    "job_type": "msuite_submit",
    "state": "succeeded",
    "entity_type": "changeset",
    "entity_id": "665a0002aabbccddee000002",
    "payload": { "changeset_id": "665a0002aabbccddee000002", "head_sha": "abc123" },
    "result": { "passed": true, "test_count": 42, "failures": [] },
    "error_message": null,
    "retry_count": 0,
    "max_retries": 3,
    "timeout_ms": 300000,
    "created_at": "2025-06-01T12:00:00Z",
    "started_at": "2025-06-01T12:00:02Z",
    "completed_at": "2025-06-01T12:01:30Z"
  }
}

{
  "data": [ /* array of JobResponse */ ],
  "pagination": { "page": 1, "limit": 20, "total": 5 }
}

db.jobs.findOneAndUpdate(
  { state: "queued" },
  { $set: { state: "running", started_at: ISODate() } },
  { sort: { created_at: 1 }, returnDocument: "after" }
)

/// Checks whether a successful job of the given type exists for the entity.
/// Returns Ok(()) if the gate passes, or ConmanError::Conflict if the
/// required job has not succeeded.
pub async fn require_job_success(
    job_repo: &JobRepo,
    app_id: &str,
    entity_type: &str,
    entity_id: &str,
    job_type: JobType,
) -> Result<(), ConmanError> {
    let filter = doc! {
        "app_id": ObjectId::parse_str(app_id)?,
        "entity_type": entity_type,
        "entity_id": ObjectId::parse_str(entity_id)?,
        "job_type": job_type.as_str(),
        "state": "succeeded",
    };

    let exists = job_repo.collection.count_documents(filter).await? > 0;

    if !exists {
        return Err(ConmanError::Conflict {
            message: format!(
                "required {} job has not succeeded for {} {}",
                job_type.as_str(), entity_type, entity_id,
            ),
        });
    }

    Ok(())
}

pub struct MsuiteSubmitWorker {
    logger: JobLogger,
}

#[async_trait]
impl JobWorker for MsuiteSubmitWorker {
    async fn execute(&self, job: &Job) -> Result<serde_json::Value, ConmanError> {
        self.logger.info("starting msuite submit validation", None).await;

        // Placeholder: simulate test execution
        // Real implementation will call external msuite service
        let changeset_id = job.payload.get("changeset_id")
            .and_then(|v| v.as_str())
            .ok_or_else(|| ConmanError::Validation {
                message: "missing changeset_id in payload".to_string(),
            })?;

        self.logger.info(
            &format!("running validation for changeset {}", changeset_id),
            Some(serde_json::json!({ "changeset_id": changeset_id })),
        ).await;

        // Simulate success
        let result = serde_json::json!({
            "passed": true,
            "test_count": 0,
            "failures": [],
            "simulated": true,
        });

        self.logger.info("msuite submit validation complete", Some(result.clone())).await;
        Ok(result)
    }
}