ex_scylla

use std::time::Duration;

use rustler::Atom;
use rustler::Error;
use rustler::NifResult;
use rustler::ResourceArc;
use rustler::Term;
use scylla::statement::prepared::PreparedStatement;

pub mod types;
use crate::consts::*;
use crate::execution::execution_profile_handle::ExecutionProfileHandleResource;
use crate::session::types::*;
use crate::types::*;
use crate::utils::*;
use scylla::value::CqlValue;
use types::*;

#[rustler::nif]
fn ps_compute_partition_key<'a>(
    ps: ResourceArc<PreparedStatementResource>,
    bound_values: Vec<Term<'a>>,
) -> NifResult<ScyllaBinary> {
    let ps: &PreparedStatement = &ps.0;
    let mut cql_values: Vec<CqlValue> = Vec::new();
    for term in bound_values {
        let sv: ScyllaValue = term.decode()?;
        cql_values.push(sv.into());
    }
    ps.compute_partition_key(&cql_values)
        .map(|b| b.into())
        .map_err(|e| Error::Term(Box::new(e.ex())))
}

#[rustler::nif]
fn ps_get_execution_profile_handle(
    ps: ResourceArc<PreparedStatementResource>,
) -> Option<ResourceArc<ExecutionProfileHandleResource>> {
    let ps: &PreparedStatement = &ps.0;
    ps.get_execution_profile_handle()
        .map(|h| ResourceArc::new(ExecutionProfileHandleResource(h.clone())))
}

#[rustler::nif]
fn ps_set_execution_profile_handle(
    ps: ResourceArc<PreparedStatementResource>,
    profile_handle: Option<ResourceArc<ExecutionProfileHandleResource>>,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_execution_profile_handle(profile_handle.map(|ephr| ephr.0.clone()));
    ps.ex()
}

#[rustler::nif]
fn ps_get_request_timeout(ps: ResourceArc<PreparedStatementResource>) -> Option<u64> {
    let ps: &PreparedStatement = &ps.0;
    ps.get_request_timeout().map(|d| d.as_millis() as u64)
}

#[rustler::nif]
fn ps_set_request_timeout(
    ps: ResourceArc<PreparedStatementResource>,
    timeout_ms: Option<u64>,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_request_timeout(timeout_ms.map(Duration::from_millis));
    ps.ex()
}

#[rustler::nif]
fn ps_is_confirmed_lwt(ps: ResourceArc<PreparedStatementResource>) -> bool {
    let ps: &PreparedStatement = &ps.0;
    ps.is_confirmed_lwt()
}

#[rustler::nif]
fn ps_get_consistency(ps: ResourceArc<PreparedStatementResource>) -> Option<ScyllaConsistency> {
    let ps: &PreparedStatement = &ps.0;
    ps.get_consistency().map(|c| c.into())
}

#[rustler::nif]
fn ps_get_id(ps: ResourceArc<PreparedStatementResource>) -> ScyllaBinary {
    let ps: &PreparedStatement = &ps.0;
    ps.get_id().to_owned().into()
}

#[rustler::nif]
fn ps_get_is_idempotent(ps: ResourceArc<PreparedStatementResource>) -> bool {
    let ps: &PreparedStatement = &ps.0;
    ps.get_is_idempotent()
}

#[rustler::nif]
fn ps_get_keyspace_name(ps: ResourceArc<PreparedStatementResource>) -> Option<String> {
    let ps: &PreparedStatement = &ps.0;
    ps.get_keyspace_name().map(|s| s.to_string())
}

#[rustler::nif]
fn ps_get_page_size(ps: ResourceArc<PreparedStatementResource>) -> Option<i32> {
    let ps: &PreparedStatement = &ps.0;
    Some(ps.get_page_size())
}

#[rustler::nif]
fn ps_get_prepare_tracing_ids(ps: ResourceArc<PreparedStatementResource>) -> Vec<ScyllaBinary> {
    let ps: &PreparedStatement = &ps.0;
    let mut vec: Vec<ScyllaBinary> = Vec::new();
    for uuid in ps.get_prepare_tracing_ids() {
        vec.push(uuid.to_owned().into());
    }
    vec
}

#[rustler::nif]
fn ps_get_prepared_metadata(ps: ResourceArc<PreparedStatementResource>) -> ScyllaPreparedMetadata {
    let ps: &PreparedStatement = &ps.0;
    ps.into()
}

#[rustler::nif]
fn ps_get_retry_policy(_ps: ResourceArc<PreparedStatementResource>) -> Atom {
    not_implemented_yet()
}

#[rustler::nif]
fn ps_get_serial_consistency(
    ps: ResourceArc<PreparedStatementResource>,
) -> Option<ScyllaSerialConsistency> {
    let ps: &PreparedStatement = &ps.0;
    ps.get_serial_consistency().map(|c| c.into())
}

#[rustler::nif]
fn ps_get_statement(ps: ResourceArc<PreparedStatementResource>) -> String {
    let ps: &PreparedStatement = &ps.0;
    ps.get_statement().to_string()
}

#[rustler::nif]
fn ps_get_table_name(ps: ResourceArc<PreparedStatementResource>) -> Option<String> {
    let ps: &PreparedStatement = &ps.0;
    ps.get_table_name().map(|tn| tn.to_string())
}

#[rustler::nif]
fn ps_get_timestamp(ps: ResourceArc<PreparedStatementResource>) -> Option<i64> {
    let ps: &PreparedStatement = &ps.0;
    ps.get_timestamp()
}

#[rustler::nif]
fn ps_get_tracing(ps: ResourceArc<PreparedStatementResource>) -> bool {
    let ps: &PreparedStatement = &ps.0;
    ps.get_tracing()
}

#[rustler::nif]
fn ps_is_token_aware(ps: ResourceArc<PreparedStatementResource>) -> bool {
    let ps: &PreparedStatement = &ps.0;
    ps.is_token_aware()
}

#[rustler::nif]
fn ps_get_use_cached_result_metadata(ps: ResourceArc<PreparedStatementResource>) -> bool {
    let ps: &PreparedStatement = &ps.0;
    ps.get_use_cached_result_metadata()
}

#[rustler::nif]
fn ps_set_use_cached_result_metadata(
    ps: ResourceArc<PreparedStatementResource>,
    use_cached_metadata: bool,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_use_cached_result_metadata(use_cached_metadata);
    ps.ex()
}

#[rustler::nif]
fn ps_set_consistency(
    ps: ResourceArc<PreparedStatementResource>,
    consistency: ScyllaConsistency,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_consistency(consistency.into());
    ps.ex()
}

#[rustler::nif]
fn ps_set_is_idempotent(
    ps: ResourceArc<PreparedStatementResource>,
    is_idempotent: bool,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_is_idempotent(is_idempotent);
    ps.ex()
}

#[rustler::nif]
fn ps_set_page_size(
    ps: ResourceArc<PreparedStatementResource>,
    page_size: i32,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_page_size(page_size);
    ps.ex()
}

#[rustler::nif]
fn ps_set_retry_policy(_ps: ResourceArc<PreparedStatementResource>) -> Atom {
    not_implemented_yet()
}

#[rustler::nif]
fn ps_set_serial_consistency(
    ps: ResourceArc<PreparedStatementResource>,
    sc: Option<ScyllaSerialConsistency>,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_serial_consistency(sc.map(|sc| sc.into()));
    ps.ex()
}

#[rustler::nif]
fn ps_set_timestamp(
    ps: ResourceArc<PreparedStatementResource>,
    timestamp_micros: Option<i64>,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_timestamp(timestamp_micros);
    ps.ex()
}

#[rustler::nif]
fn ps_set_tracing(
    ps: ResourceArc<PreparedStatementResource>,
    should_trace: bool,
) -> ResourceArc<PreparedStatementResource> {
    let mut ps: PreparedStatement = ps.0.to_owned();
    ps.set_tracing(should_trace);
    ps.ex()
}