use admin::services::tasks::{
    BulkTaskFailure, BulkTaskResp, TaskActionResp, TaskDetailDto, TaskDto, TaskPageDto,
    TaskSourceStatDto, TaskStatsDto,
};

use crate::convert::{opt_ts, ts};
use crate::proto as pb;

pub fn task(value: TaskDto) -> pb::Task {
    pb::Task {
        id: value.id.to_string(),
        source: value.source,
        title: value.title,
        state: value.state,
        created_at: ts(value.created_at),
        updated_at: opt_ts(value.updated_at),
        finished_at: opt_ts(value.finished_at),
        last_error: value.last_error,
    }
}

pub fn task_page(value: TaskPageDto) -> pb::TaskPage {
    pb::TaskPage {
        items: value.items.into_iter().map(task).collect(),
        total: value.total,
        limit: value.limit,
        offset: value.offset,
    }
}

pub fn task_detail(value: TaskDetailDto) -> pb::TaskDetail {
    pb::TaskDetail {
        task: Some(task(value.task)),
        detail: value.detail.to_string(),
    }
}

pub fn action_resp(value: TaskActionResp) -> pb::TaskActionResp {
    pb::TaskActionResp {
        source: value.source,
        id: value.id.to_string(),
        state: value.state,
    }
}

pub fn source_stat(value: TaskSourceStatDto) -> pb::TaskSourceStat {
    pb::TaskSourceStat {
        source: value.source,
        queued: value.queued,
        running: value.running,
        succeeded: value.succeeded,
        failed: value.failed,
    }
}

pub fn stats(value: TaskStatsDto) -> pb::TaskStats {
    pb::TaskStats {
        sources: value.sources.into_iter().map(source_stat).collect(),
        total: value.total,
        generated_at: ts(value.generated_at),
    }
}

pub fn bulk_failure(value: BulkTaskFailure) -> pb::BulkTaskFailure {
    pb::BulkTaskFailure {
        id: value.id.to_string(),
        error: value.error,
    }
}

pub fn bulk_resp(value: BulkTaskResp) -> pb::BulkTasksResp {
    pb::BulkTasksResp {
        source: value.source,
        action: value.action,
        succeeded: value
            .succeeded
            .into_iter()
            .map(|id| id.to_string())
            .collect(),
        failed: value.failed.into_iter().map(bulk_failure).collect(),
    }
}