// 保留原单次入口参照，另外区分入口成本和同一入口内连续执行的任务成本。
// 每个 steady 样本仍逐次创建、等待并清理真实任务，只复用父入口。

const CONTINUOUS_CALLS: usize = 16;

// 与 Dever async_total 保持同样的可失败计时分支和携带文本的错误合同，不加填充字段。
enum NativeAsyncFailure {
    Fault(Fault),
    Sleep(String, Fault),
}

impl From<Fault> for NativeAsyncFailure {
    fn from(value: Fault) -> Self {
        Self::Fault(value)
    }
}

impl From<NativeAsyncFailure> for Fault {
    fn from(value: NativeAsyncFailure) -> Self {
        match value {
            NativeAsyncFailure::Fault(fault) => fault,
            NativeAsyncFailure::Sleep(message, fault) => {
                drop(message);
                fault
            }
        }
    }
}

async fn native_fallible_sleep(millis: i64) -> Result<(), NativeAsyncFailure> {
    let fail = |message: &str| NativeAsyncFailure::Sleep(message.to_owned(), task_fault("timer"));
    let millis = u64::try_from(millis).map_err(|_| fail("sleep duration must be nonnegative"))?;
    let deadline = tokio::time::Instant::now()
        .checked_add(Duration::from_millis(millis))
        .ok_or_else(|| fail("sleep deadline is out of range"))?;
    tokio::time::sleep_until(deadline).await;
    Ok(())
}

async fn native_async_total(values: Vec<i64>, delayed: bool) -> Result<i64, NativeAsyncFailure> {
    if delayed {
        native_fallible_sleep(0).await?;
    }
    native_total(&values).map_err(Into::into)
}

// 仅作成本诊断：保留原始 Rust 参照，另测附带完成跟踪的相同双任务负载。
// 元组先放返回值再放令牌，未领取结果的析构顺序与生产运行库相同。
fn native_tracked<Failure, Work>(
    native: &NativeTasks,
    work: Work,
    cancel: CancellationToken,
    tracking: tokio_util::task::task_tracker::TaskTrackerToken,
) -> JoinHandle<(
    Result<i64, Failure>,
    tokio_util::task::task_tracker::TaskTrackerToken,
)>
where
    Failure: From<Fault> + Send + 'static,
    Work: std::future::Future<Output = Result<i64, Failure>> + Send + 'static,
{
    let admission = native.tasks.clone().try_acquire_owned().unwrap();
    let workers = native.workers.clone();
    tokio::spawn(async move {
        let tracking = tracking;
        let result = tokio::select! {
            biased;
            result = work => result,
            () = cancel.cancelled() => Err(task_fault("cancelled").into()),
        };
        drop(workers);
        drop(admission);
        (result, tracking)
    })
}

fn reference_async_tracked(values: &[TaskCase]) -> Result<i64, Fault> {
    reference_tracked(values, |values| async move { native_total(&values) })
}

fn reference_async_typed(values: &[TaskCase]) -> Result<i64, Fault> {
    reference_tracked(values, |values| native_async_total(values, false))
}

fn reference_tracked<Failure, Work>(
    values: &[TaskCase],
    call: impl Fn(Vec<i64>) -> Work,
) -> Result<i64, Fault>
where
    Failure: From<Fault> + Into<Fault> + Send + 'static,
    Work: std::future::Future<Output = Result<i64, Failure>> + Send + 'static,
{
    let Some(value) = values.first() else {
        return Ok(0);
    };
    value.native.runtime.block_on(async {
        let cancel = CancellationToken::new();
        let tasks = tokio_util::task::TaskTracker::new();
        let outcome = async {
            let mut total = 0i64;
            for _ in 0..CONTINUOUS_CALLS {
                let first = native_tracked(
                    &value.native,
                    call(value.values.clone()),
                    cancel.child_token(),
                    tasks.token(),
                );
                let second = native_tracked(
                    &value.native,
                    call(value.values.clone()),
                    cancel.child_token(),
                    tasks.token(),
                );
                let first = first
                    .await
                    .map_err(task_fault)
                    .and_then(|(result, _tracking)| result.map_err(Into::into));
                if first.is_err() {
                    cancel.cancel();
                }
                let second = second
                    .await
                    .map_err(task_fault)
                    .and_then(|(result, _tracking)| result.map_err(Into::into));
                let result = first?
                    .checked_add(second?)
                    .ok_or_else(|| task_fault("integer overflow"))?;
                total = total
                    .checked_add(result)
                    .ok_or_else(|| task_fault("integer overflow"))?;
            }
            Ok(total)
        }
        .await;
        cancel.cancel();
        tasks.close();
        tasks.wait().await;
        outcome
    })
}

fn generated_entry(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else {
        return Ok(0);
    };
    value.generated.run(async |_| 1i64).map_err(task_fault)
}

fn reference_entry(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else {
        return Ok(0);
    };
    Ok(value.native.runtime.block_on(async { 1i64 }))
}

fn generated_leaf_entry(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else { return Ok(0); };
    value.generated.run_leaf(async { 1i64 }).map_err(task_fault)
}

fn generated_async_steady(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else {
        return Ok(0);
    };
    value
        .generated
        .run(async |scope| {
            let mut total = 0i64;
            for _ in 0..CONTINUOUS_CALLS {
                let result = GENERATED_ASYNC(&value.values, scope)
                    .await
                    .map_err(task_fault)?;
                total = total
                    .checked_add(result)
                    .ok_or_else(|| task_fault("integer overflow"))?;
            }
            Ok(total)
        })
        .map_err(task_fault)?
}

fn reference_async_steady(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else {
        return Ok(0);
    };
    value.native.runtime.block_on(async {
        let cancel = CancellationToken::new();
        let mut total = 0i64;
        for _ in 0..CONTINUOUS_CALLS {
            let first = value
                .native
                .start(value.values.clone(), true, cancel.child_token());
            let second = value
                .native
                .start(value.values.clone(), true, cancel.child_token());
            let first = first.await.map_err(task_fault).and_then(|result| result);
            if first.is_err() {
                cancel.cancel();
            }
            let second = second.await.map_err(task_fault).and_then(|result| result);
            let result = first?
                .checked_add(second?)
                .ok_or_else(|| task_fault("integer overflow"))?;
            total = total
                .checked_add(result)
                .ok_or_else(|| task_fault("integer overflow"))?;
        }
        cancel.cancel();
        Ok(total)
    })
}

fn generated_cancel_steady(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else {
        return Ok(0);
    };
    value
        .generated
        .run(async |scope| {
            let mut total = 0i64;
            for _ in 0..CONTINUOUS_CALLS {
                let result = GENERATED_CANCEL(scope).await.map_err(task_fault)?;
                total = total
                    .checked_add(result)
                    .ok_or_else(|| task_fault("integer overflow"))?;
            }
            Ok(total)
        })
        .map_err(task_fault)?
}

fn reference_cancel_steady(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else {
        return Ok(0);
    };
    value.native.runtime.block_on(async {
        let root = CancellationToken::new();
        let mut total = 0i64;
        for _ in 0..CONTINUOUS_CALLS {
            let admission = value.native.tasks.clone().try_acquire_owned().unwrap();
            let cancel = root.child_token();
            let child = cancel.clone();
            let task = tokio::spawn(async move {
                let deadline = tokio::time::Instant::now()
                    .checked_add(Duration::from_millis(60000))
                    .unwrap();
                tokio::select! {
                    biased;
                    () = tokio::time::sleep_until(deadline) => panic!("cancelled timer completed"),
                    () = child.cancelled() => (),
                }
                drop(admission);
            });
            cancel.cancel();
            task.await.map_err(task_fault)?;
            total = total
                .checked_add(1)
                .ok_or_else(|| task_fault("integer overflow"))?;
        }
        root.cancel();
        Ok(total)
    })
}

// 取消机制采用标准 JoinHandle::abort 的独立 Rust 对照；原 token 对照继续保留。
fn reference_cancel_abort(values: &[TaskCase]) -> Result<i64, Fault> {
    let Some(value) = values.first() else { return Ok(0); };
    value.native.runtime.block_on(async {
        let admission = value.native.tasks.clone().try_acquire_owned().unwrap();
        let task = tokio::spawn(async move {
            let _admission = admission;
            let deadline = tokio::time::Instant::now()
                .checked_add(Duration::from_millis(60000))
                .ok_or_else(|| task_fault("sleep deadline"))?;
            tokio::time::sleep_until(deadline).await;
            Ok::<(), Fault>(())
        });
        task.abort();
        match task.await {
            Err(error) if error.is_cancelled() => Ok(1),
            Err(error) => Err(task_fault(error)),
            Ok(result) => { result?; Err(task_fault("cancelled timer completed")) }
        }
    })
}

fn lifecycle(cases: &[TaskCase]) {
    let expected = native_total(&cases[0].values).unwrap() * 2 * CONTINUOUS_CALLS as i64;
    assert_eq!(generated_async_steady(cases).unwrap(), expected);
    assert_eq!(reference_async_steady(cases).unwrap(), expected);
    assert_eq!(reference_async_tracked(cases).unwrap(), expected);
    assert_eq!(reference_async_typed(cases).unwrap(), expected);
    let native = &cases[0].native;
    assert_eq!(
        native
            .runtime
            .block_on(native_async_total(cases[0].values.clone(), true))
            .map_err(Fault::from)
            .unwrap(),
        expected / CONTINUOUS_CALLS as i64 / 2
    );
    assert!(native.runtime.block_on(native_fallible_sleep(-1)).is_err());
    eprintln!(
        "result-layout: rust_typed_async={}",
        std::mem::size_of::<Result<i64, NativeAsyncFailure>>()
    );
    assert_eq!(
        generated_cancel_steady(cases).unwrap(),
        CONTINUOUS_CALLS as i64
    );
    assert_eq!(
        reference_cancel_steady(cases).unwrap(),
        CONTINUOUS_CALLS as i64
    );
    cases[0]
        .generated
        .run(async |scope| {
            eprintln!(
                "task-layout: task={} optional_task={}",
                std::mem::size_of::<dever_runtime::task::Task<()>>(),
                std::mem::size_of::<Option<dever_runtime::task::Task<()>>>(),
            );
            eprintln!(
                "future-layout: fault={} dever_pair={} rust_pair={} dever_cancel={} rust_cancel={}",
                std::mem::size_of::<Fault>(),
                std::mem::size_of_val(&GENERATED_ASYNC(&cases[0].values, scope)),
                std::mem::size_of_val(&handwritten_pair(scope, &cases[0].values)),
                std::mem::size_of_val(&GENERATED_CANCEL(scope)),
                std::mem::size_of_val(&handwritten_cancel(scope)),
            );
            let result = GENERATED_ASYNC(&cases[0].values, scope).await;
            eprintln!(
                "result-layout: dever_async={} rust_async={}",
                std::mem::size_of_val(&result),
                std::mem::size_of::<Result<i64, Fault>>()
            );
            let result = GENERATED_CANCEL(scope).await;
            eprintln!(
                "result-layout: dever_cancel={} rust_cancel={}",
                std::mem::size_of_val(&result),
                std::mem::size_of::<Result<i64, Fault>>()
            );
        })
        .unwrap();
    compare(
        "task_entry_ready",
        cases,
        100000,
        generated_entry,
        reference_entry,
        |value| *value as u64,
    );
    compare(
        "task_leaf_entry_ready",
        cases,
        100000,
        generated_leaf_entry,
        reference_entry,
        |value| *value as u64,
    );
    compare(
        "task_async_steady",
        cases,
        64,
        generated_async_steady,
        reference_async_steady,
        |value| *value as u64,
    );
    compare(
        "task_cancel_steady",
        cases,
        64,
        generated_cancel_steady,
        reference_cancel_steady,
        |value| *value as u64,
    );
    compare_named(
        "task_async_tracked_diagnostic",
        cases,
        64,
        generated_async_steady,
        reference_async_tracked,
        |value| *value as u64,
        "rust_tracked",
    );
    compare_named(
        "task_async_typed_diagnostic",
        cases,
        64,
        generated_async_steady,
        reference_async_typed,
        |value| *value as u64,
        "rust_typed",
    );
    compare_named(
        "task_cancel_abort_diagnostic",
        cases,
        1000,
        generated_cancel,
        reference_cancel_abort,
        |value| *value as u64,
        "rust_abort",
    );
}