// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.

//! Cast kernels to convert [`ArrayRef`]  between supported datatypes.

//!

//! See [`cast_with_options`] for more information on specific conversions.

//!

//! Example:

//!

//! ```

//! # use arrow_array::*;

//! # use arrow_cast::cast;

//! # use arrow_schema::DataType;

//! # use std::sync::Arc;

//! # use arrow_array::types::Float64Type;

//! # use arrow_array::cast::AsArray;

//! // int32 to float64

//! let a = Int32Array::from(vec![5, 6, 7]);

//! let b = cast(&a, &DataType::Float64).unwrap();

//! let c = b.as_primitive::<Float64Type>();

//! assert_eq!(5.0, c.value(0));

//! assert_eq!(6.0, c.value(1));

//! assert_eq!(7.0, c.value(2));

//! ```

mod decimal;

mod dictionary;

mod list;

mod map;

mod string;

use crate::cast::decimal::*;

use crate::cast::dictionary::*;

use crate::cast::list::*;

use crate::cast::map::*;

use crate::cast::string::*;

use arrow_buffer::IntervalMonthDayNano;

use arrow_data::ByteView;

use chrono::{NaiveTime, Offset, TimeZone, Utc};

use std::cmp::Ordering;

use std::sync::Arc;

use crate::display::{ArrayFormatter, FormatOptions};

use crate::parse::{

    parse_interval_day_time, parse_interval_month_day_nano, parse_interval_year_month,

    string_to_datetime, Parser,

};

use arrow_array::{builder::*, cast::*, temporal_conversions::*, timezone::Tz, types::*, *};

use arrow_buffer::{i256, ArrowNativeType, OffsetBuffer};

use arrow_data::transform::MutableArrayData;

use arrow_data::ArrayData;

use arrow_schema::*;

use arrow_select::take::take;

use num::cast::AsPrimitive;

use num::{NumCast, ToPrimitive};

/// CastOptions provides a way to override the default cast behaviors

#[derive(Debug, Clone, PartialEq, Eq, Hash)]

pub struct CastOptions<'a> {

    /// how to handle cast failures, either return NULL (safe=true) or return ERR (safe=false)

    pub safe: bool,

    /// Formatting options when casting from temporal types to string

    pub format_options: FormatOptions<'a>,

}

impl Default for CastOptions<'_> {

    fn default() -> Self {

        Self {

            safe: true,

            format_options: FormatOptions::default(),

        }

    }

}

/// Return true if a value of type `from_type` can be cast into a value of `to_type`.

///

/// See [`cast_with_options`] for more information

pub fn can_cast_types(from_type: &DataType, to_type: &DataType) -> bool {

    use self::DataType::*;

    use self::IntervalUnit::*;

    use self::TimeUnit::*;

    if from_type == to_type {

        return true;

    }

    match (from_type, to_type) {

        (

            Null,

            Boolean

            | Int8

            | UInt8

            | Int16

            | UInt16

            | Int32

            | UInt32

            | Float32

            | Date32

            | Time32(_)

            | Int64

            | UInt64

            | Float64

            | Date64

            | Timestamp(_, _)

            | Time64(_)

            | Duration(_)

            | Interval(_)

            | FixedSizeBinary(_)

            | Binary

            | Utf8

            | LargeBinary

            | LargeUtf8

            | BinaryView

            | Utf8View

            | List(_)

            | LargeList(_)

            | FixedSizeList(_, _)

            | Struct(_)

            | Map(_, _)

            | Dictionary(_, _),

        ) => true,

        // Dictionary/List conditions should be put in front of others

        (Dictionary(_, from_value_type), Dictionary(_, to_value_type)) => {

            can_cast_types(from_value_type, to_value_type)

        }

        (Dictionary(_, value_type), _) => can_cast_types(value_type, to_type),

        (_, Dictionary(_, value_type)) => can_cast_types(from_type, value_type),

        (List(list_from) | LargeList(list_from), List(list_to) | LargeList(list_to)) => {

            can_cast_types(list_from.data_type(), list_to.data_type())

        }

        (List(list_from) | LargeList(list_from), Utf8 | LargeUtf8) => {

            can_cast_types(list_from.data_type(), to_type)

        }

        (List(list_from) | LargeList(list_from), FixedSizeList(list_to, _)) => {

            can_cast_types(list_from.data_type(), list_to.data_type())

        }

        (List(_), _) => false,

        (FixedSizeList(list_from, _), List(list_to))

        | (FixedSizeList(list_from, _), LargeList(list_to)) => {

            can_cast_types(list_from.data_type(), list_to.data_type())

        }

        (FixedSizeList(inner, size), FixedSizeList(inner_to, size_to)) if size == size_to => {

            can_cast_types(inner.data_type(), inner_to.data_type())

        }

        (_, List(list_to)) => can_cast_types(from_type, list_to.data_type()),

        (_, LargeList(list_to)) => can_cast_types(from_type, list_to.data_type()),

        (_, FixedSizeList(list_to, size)) if *size == 1 => {

            can_cast_types(from_type, list_to.data_type())

        }

        (FixedSizeList(list_from, size), _) if *size == 1 => {

            can_cast_types(list_from.data_type(), to_type)

        }

        (Map(from_entries, ordered_from), Map(to_entries, ordered_to))

            if ordered_from == ordered_to =>

        {

            match (

                key_field(from_entries),

                key_field(to_entries),

                value_field(from_entries),

                value_field(to_entries),

            ) {

                (Some(from_key), Some(to_key), Some(from_value), Some(to_value)) => {

                    can_cast_types(from_key.data_type(), to_key.data_type())

                        && can_cast_types(from_value.data_type(), to_value.data_type())

                }

                _ => false,

            }

        }

        // cast one decimal type to another decimal type

        (

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

        ) => true,

        // unsigned integer to decimal

        (

            UInt8 | UInt16 | UInt32 | UInt64,

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

        ) => true,

        // signed numeric to decimal

        (

            Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

        ) => true,

        // decimal to unsigned numeric

        (

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

            UInt8 | UInt16 | UInt32 | UInt64,

        ) => true,

        // decimal to signed numeric

        (

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

            Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,

        ) => true,

        // decimal to string

        (

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

            Utf8View | Utf8 | LargeUtf8,

        ) => true,

        // string to decimal

        (

            Utf8View | Utf8 | LargeUtf8,

            Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),

        ) => true,

        (Struct(from_fields), Struct(to_fields)) => {

            from_fields.len() == to_fields.len()

                && from_fields.iter().zip(to_fields.iter()).all(|(f1, f2)| {

                    // Assume that nullability between two structs are compatible, if not,

                    // cast kernel will return error.

                    can_cast_types(f1.data_type(), f2.data_type())

                })

        }

        (Struct(_), _) => false,

        (_, Struct(_)) => false,

        (_, Boolean) => {

            DataType::is_integer(from_type)

                || DataType::is_floating(from_type)

                || from_type == &Utf8View

                || from_type == &Utf8

                || from_type == &LargeUtf8

        }

        (Boolean, _) => {

            DataType::is_integer(to_type)

                || DataType::is_floating(to_type)

                || to_type == &Utf8View

                || to_type == &Utf8

                || to_type == &LargeUtf8

        }

        (Binary, LargeBinary | Utf8 | LargeUtf8 | FixedSizeBinary(_) | BinaryView | Utf8View) => {

            true

        }

        (LargeBinary, Binary | Utf8 | LargeUtf8 | FixedSizeBinary(_) | BinaryView | Utf8View) => {

            true

        }

        (FixedSizeBinary(_), Binary | LargeBinary | BinaryView) => true,

        (

            Utf8 | LargeUtf8 | Utf8View,

            Binary

            | LargeBinary

            | Utf8

            | LargeUtf8

            | Date32

            | Date64

            | Time32(Second)

            | Time32(Millisecond)

            | Time64(Microsecond)

            | Time64(Nanosecond)

            | Timestamp(Second, _)

            | Timestamp(Millisecond, _)

            | Timestamp(Microsecond, _)

            | Timestamp(Nanosecond, _)

            | Interval(_)

            | BinaryView,

        ) => true,

        (Utf8 | LargeUtf8, Utf8View) => true,

        (BinaryView, Binary | LargeBinary | Utf8 | LargeUtf8 | Utf8View) => true,

        (Utf8View | Utf8 | LargeUtf8, _) => to_type.is_numeric() && to_type != &Float16,

        (_, Utf8 | LargeUtf8) => from_type.is_primitive(),

        (_, Utf8View) => from_type.is_numeric(),

        (_, Binary | LargeBinary) => from_type.is_integer(),

        // start numeric casts

        (

            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float16 | Float32

            | Float64,

            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float16 | Float32

            | Float64,

        ) => true,

        // end numeric casts

        // temporal casts

        (Int32, Date32 | Date64 | Time32(_)) => true,

        (Date32, Int32 | Int64) => true,

        (Time32(_), Int32) => true,

        (Int64, Date64 | Date32 | Time64(_)) => true,

        (Date64, Int64 | Int32) => true,

        (Time64(_), Int64) => true,

        (Date32 | Date64, Date32 | Date64) => true,

        // time casts

        (Time32(_), Time32(_)) => true,

        (Time32(_), Time64(_)) => true,

        (Time64(_), Time64(_)) => true,

        (Time64(_), Time32(to_unit)) => {

            matches!(to_unit, Second | Millisecond)

        }

        (Timestamp(_, _), _) if to_type.is_numeric() => true,

        (_, Timestamp(_, _)) if from_type.is_numeric() => true,

        (Date64, Timestamp(_, _)) => true,

        (Date32, Timestamp(_, _)) => true,

        (

            Timestamp(_, _),

            Timestamp(_, _)

            | Date32

            | Date64

            | Time32(Second)

            | Time32(Millisecond)

            | Time64(Microsecond)

            | Time64(Nanosecond),

        ) => true,

        (_, Duration(_)) if from_type.is_numeric() => true,

        (Duration(_), _) if to_type.is_numeric() => true,

        (Duration(_), Duration(_)) => true,

        (Interval(from_type), Int64) => {

            match from_type {

                YearMonth => true,

                DayTime => true,

                MonthDayNano => false, // Native type is i128

            }

        }

        (Int32, Interval(to_type)) => match to_type {

            YearMonth => true,

            DayTime => false,

            MonthDayNano => false,

        },

        (Duration(_), Interval(MonthDayNano)) => true,

        (Interval(MonthDayNano), Duration(_)) => true,

        (Interval(YearMonth), Interval(MonthDayNano)) => true,

        (Interval(DayTime), Interval(MonthDayNano)) => true,

        (_, _) => false,

    }

}

/// Cast `array` to the provided data type and return a new Array with type `to_type`, if possible.

///

/// See [`cast_with_options`] for more information

pub fn cast(array: &dyn Array, to_type: &DataType) -> Result<ArrayRef, ArrowError> {

    cast_with_options(array, to_type, &CastOptions::default())

}

fn cast_integer_to_decimal<

    T: ArrowPrimitiveType,

    D: DecimalType + ArrowPrimitiveType<Native = M>,

    M,

>(

    array: &PrimitiveArray<T>,

    precision: u8,

    scale: i8,

    base: M,

    cast_options: &CastOptions,

) -> Result<ArrayRef, ArrowError>

where

    <T as ArrowPrimitiveType>::Native: AsPrimitive<M>,

    M: ArrowNativeTypeOp,

{

    let scale_factor = base.pow_checked(scale.unsigned_abs() as u32).map_err(|_| {

        ArrowError::CastError(format!(

            "Cannot cast to {:?}({}, {}). The scale causes overflow.",

            D::PREFIX,

            precision,

            scale,

        ))

    })?;

    let array = if scale < 0 {

        match cast_options.safe {

            true => array.unary_opt::<_, D>(|v| {

                v.as_()

                    .div_checked(scale_factor)

                    .ok()

                    .and_then(|v| (D::is_valid_decimal_precision(v, precision)).then_some(v))

            }),

            false => array.try_unary::<_, D, _>(|v| {

                v.as_()

                    .div_checked(scale_factor)

                    .and_then(|v| D::validate_decimal_precision(v, precision).map(|_| v))

            })?,

        }

    } else {

        match cast_options.safe {

            true => array.unary_opt::<_, D>(|v| {

                v.as_()

                    .mul_checked(scale_factor)

                    .ok()

                    .and_then(|v| (D::is_valid_decimal_precision(v, precision)).then_some(v))

            }),

            false => array.try_unary::<_, D, _>(|v| {

                v.as_()

                    .mul_checked(scale_factor)

                    .and_then(|v| D::validate_decimal_precision(v, precision).map(|_| v))

            })?,

        }

    };

    Ok(Arc::new(array.with_precision_and_scale(precision, scale)?))

}

/// Cast the array from interval year month to month day nano

fn cast_interval_year_month_to_interval_month_day_nano(

    array: &dyn Array,

    _cast_options: &CastOptions,

) -> Result<ArrayRef, ArrowError> {

    let array = array.as_primitive::<IntervalYearMonthType>();

    Ok(Arc::new(array.unary::<_, IntervalMonthDayNanoType>(|v| {

        let months = IntervalYearMonthType::to_months(v);

        IntervalMonthDayNanoType::make_value(months, 0, 0)

    })))

}

/// Cast the array from interval day time to month day nano

fn cast_interval_day_time_to_interval_month_day_nano(

    array: &dyn Array,

    _cast_options: &CastOptions,

) -> Result<ArrayRef, ArrowError> {

    let array = array.as_primitive::<IntervalDayTimeType>();

    let mul = 1_000_000;

    Ok(Arc::new(array.unary::<_, IntervalMonthDayNanoType>(|v| {

        let (days, ms) = IntervalDayTimeType::to_parts(v);

        IntervalMonthDayNanoType::make_value(0, days, ms as i64 * mul)

    })))

}

/// Cast the array from interval to duration

fn cast_month_day_nano_to_duration<D: ArrowTemporalType<Native = i64>>(

    array: &dyn Array,

    cast_options: &CastOptions,

) -> Result<ArrayRef, ArrowError> {

    let array = array.as_primitive::<IntervalMonthDayNanoType>();

    let scale = match D::DATA_TYPE {

        DataType::Duration(TimeUnit::Second) => 1_000_000_000,

        DataType::Duration(TimeUnit::Millisecond) => 1_000_000,

        DataType::Duration(TimeUnit::Microsecond) => 1_000,

        DataType::Duration(TimeUnit::Nanosecond) => 1,

        _ => unreachable!(),

    };

    if cast_options.safe {

        let iter = array.iter().map(|v| {

            v.and_then(|v| (v.days == 0 && v.months == 0).then_some(v.nanoseconds / scale))

        });

        Ok(Arc::new(unsafe {

            PrimitiveArray::<D>::from_trusted_len_iter(iter)

        }))

    } else {

        let vec = array

            .iter()

            .map(|v| {

                v.map(|v| match v.days == 0 && v.months == 0 {

                    true => Ok((v.nanoseconds) / scale),

                    _ => Err(ArrowError::ComputeError(

                        "Cannot convert interval containing non-zero months or days to duration"

                            .to_string(),

                    )),

                })

                .transpose()

            })

            .collect::<Result<Vec<_>, _>>()?;

        Ok(Arc::new(unsafe {

            PrimitiveArray::<D>::from_trusted_len_iter(vec.iter())

        }))

    }

}

/// Cast the array from duration and interval

fn cast_duration_to_interval<D: ArrowTemporalType<Native = i64>>(

    array: &dyn Array,

    cast_options: &CastOptions,

) -> Result<ArrayRef, ArrowError> {

    let array = array

        .as_any()

        .downcast_ref::<PrimitiveArray<D>>()

        .ok_or_else(|| {

            ArrowError::ComputeError(

                "Internal Error: Cannot cast duration to DurationArray of expected type"

                    .to_string(),

            )

        })?;

    let scale = match array.data_type() {

        DataType::Duration(TimeUnit::Second) => 1_000_000_000,

        DataType::Duration(TimeUnit::Millisecond) => 1_000_000,

        DataType::Duration(TimeUnit::Microsecond) => 1_000,

        DataType::Duration(TimeUnit::Nanosecond) => 1,

        _ => unreachable!(),

    };

    if cast_options.safe {

        let iter = array.iter().map(|v| {

            v.and_then(|v| {

                v.checked_mul(scale)

                    .map(|v| IntervalMonthDayNano::new(0, 0, v))

            })

        });

        Ok(Arc::new(unsafe {

            PrimitiveArray::<IntervalMonthDayNanoType>::from_trusted_len_iter(iter)

        }))

    } else {

        let vec = array

            .iter()

            .map(|v| {

                v.map(|v| {

                    if let Ok(v) = v.mul_checked(scale) {

                        Ok(IntervalMonthDayNano::new(0, 0, v))

                    } else {

                        Err(ArrowError::ComputeError(format!(

                            "Cannot cast to {:?}. Overflowing on {:?}",

                            IntervalMonthDayNanoType::DATA_TYPE,

                            v

                        )))

                    }

                })

                .transpose()

            })

            .collect::<Result<Vec<_>, _>>()?;

        Ok(Arc::new(unsafe {

            PrimitiveArray::<IntervalMonthDayNanoType>::from_trusted_len_iter(vec.iter())

        }))

    }

}

/// Cast the primitive array using [`PrimitiveArray::reinterpret_cast`]

fn cast_reinterpret_arrays<I: ArrowPrimitiveType, O: ArrowPrimitiveType<Native = I::Native>>(

    array: &dyn Array,

) -> Result<ArrayRef, ArrowError> {

    Ok(Arc::new(array.as_primitive::<I>().reinterpret_cast::<O>()))

}

fn make_timestamp_array(

    array: &PrimitiveArray<Int64Type>,

    unit: TimeUnit,

    tz: Option<Arc<str>>,

) -> ArrayRef {

    match unit {

        TimeUnit::Second => Arc::new(

            array

                .reinterpret_cast::<TimestampSecondType>()

                .with_timezone_opt(tz),

        ),

        TimeUnit::Millisecond => Arc::new(

            array

                .reinterpret_cast::<TimestampMillisecondType>()

                .with_timezone_opt(tz),

        ),

        TimeUnit::Microsecond => Arc::new(

            array

                .reinterpret_cast::<TimestampMicrosecondType>()

                .with_timezone_opt(tz),

        ),

        TimeUnit::Nanosecond => Arc::new(

            array

                .reinterpret_cast::<TimestampNanosecondType>()

                .with_timezone_opt(tz),

        ),

    }

}

fn make_duration_array(array: &PrimitiveArray<Int64Type>, unit: TimeUnit) -> ArrayRef {

    match unit {

        TimeUnit::Second => Arc::new(array.reinterpret_cast::<DurationSecondType>()),

        TimeUnit::Millisecond => Arc::new(array.reinterpret_cast::<DurationMillisecondType>()),

        TimeUnit::Microsecond => Arc::new(array.reinterpret_cast::<DurationMicrosecondType>()),

        TimeUnit::Nanosecond => Arc::new(array.reinterpret_cast::<DurationNanosecondType>()),

    }

}

fn as_time_res_with_timezone<T: ArrowPrimitiveType>(

    v: i64,

    tz: Option<Tz>,

) -> Result<NaiveTime, ArrowError> {

    let time = match tz {

        Some(tz) => as_datetime_with_timezone::<T>(v, tz).map(|d| d.time()),

        None => as_datetime::<T>(v).map(|d| d.time()),

    };

    time.ok_or_else(|| {

        ArrowError::CastError(format!(

            "Failed to create naive time with {} {}",

            std::any::type_name::<T>(),

            v

        ))

    })

}

fn timestamp_to_date32<T: ArrowTimestampType>(

    array: &PrimitiveArray<T>,

) -> Result<ArrayRef, ArrowError> {

    let err = |x: i64| {

        ArrowError::CastError(format!(

            "Cannot convert {} {x} to datetime",

            std::any::type_name::<T>()

        ))

    };

    let array: Date32Array = match array.timezone() {

        Some(tz) => {

            let tz: Tz = tz.parse()?;

            array.try_unary(|x| {

                as_datetime_with_timezone::<T>(x, tz)

                    .ok_or_else(|| err(x))

                    .map(|d| Date32Type::from_naive_date(d.date_naive()))

            })?

        }

        None => array.try_unary(|x| {

            as_datetime::<T>(x)

                .ok_or_else(|| err(x))

                .map(|d| Date32Type::from_naive_date(d.date()))

        })?,

    };

    Ok(Arc::new(array))

}

/// Try to cast `array` to `to_type` if possible.

///

/// Returns a new Array with type `to_type` if possible.

///

/// Accepts [`CastOptions`] to specify cast behavior. See also [`cast()`].

///

/// # Behavior

/// * `Boolean` to `Utf8`: `true` => '1', `false` => `0`

/// * `Utf8` to `Boolean`: `true`, `yes`, `on`, `1` => `true`, `false`, `no`, `off`, `0` => `false`,

///   short variants are accepted, other strings return null or error

/// * `Utf8` to Numeric: strings that can't be parsed to numbers return null, float strings

///   in integer casts return null

/// * Numeric to `Boolean`: 0 returns `false`, any other value returns `true`

/// * `List` to `List`: the underlying data type is cast

/// * `List` to `FixedSizeList`: the underlying data type is cast. If safe is true and a list element

///   has the wrong length it will be replaced with NULL, otherwise an error will be returned

/// * Primitive to `List`: a list array with 1 value per slot is created

/// * `Date32` and `Date64`: precision lost when going to higher interval

/// * `Time32 and `Time64`: precision lost when going to higher interval

/// * `Timestamp` and `Date{32|64}`: precision lost when going to higher interval

/// * Temporal to/from backing Primitive: zero-copy with data type change

/// * `Float32/Float64` to `Decimal(precision, scale)` rounds to the `scale` decimals

///   (i.e. casting `6.4999` to `Decimal(10, 1)` becomes `6.5`).

/// * `Decimal` to `Float32/Float64` is lossy and values outside the representable

///   range become `INFINITY` or `-INFINITY` without error.

///

/// Unsupported Casts (check with `can_cast_types` before calling):

/// * To or from `StructArray`

/// * `List` to `Primitive`

/// * `Interval` and `Duration`

///

/// # Durations and Intervals

///

/// Casting integer types directly to interval types such as

/// [`IntervalMonthDayNano`] is not supported because the meaning of the integer

/// is ambiguous. For example, the integer  could represent either nanoseconds

/// or months.

///

/// To cast an integer type to an interval type, first convert to a Duration

/// type, and then cast that to the desired interval type.

///

/// For example, to convert an `Int64` representing nanoseconds to an

/// `IntervalMonthDayNano` you would first convert the `Int64` to a

/// `DurationNanoseconds`, and then cast that to `IntervalMonthDayNano`.

///

/// # Timestamps and Timezones

///

/// Timestamps are stored with an optional timezone in Arrow.

///

/// ## Casting timestamps to a timestamp without timezone / UTC

/// ```

/// # use arrow_array::Int64Array;

/// # use arrow_array::types::TimestampSecondType;

/// # use arrow_cast::{cast, display};

/// # use arrow_array::cast::AsArray;

/// # use arrow_schema::{DataType, TimeUnit};

/// // can use "UTC" if chrono-tz feature is enabled, here use offset based timezone

/// let data_type = DataType::Timestamp(TimeUnit::Second, None);

/// let a = Int64Array::from(vec![1_000_000_000, 2_000_000_000, 3_000_000_000]);

/// let b = cast(&a, &data_type).unwrap();

/// let b = b.as_primitive::<TimestampSecondType>(); // downcast to result type

/// assert_eq!(2_000_000_000, b.value(1)); // values are the same as the type has no timezone

/// // use display to show them (note has no trailing Z)

/// assert_eq!("2033-05-18T03:33:20", display::array_value_to_string(&b, 1).unwrap());

/// ```

///

/// ## Casting timestamps to a timestamp with timezone

///

/// Similarly to the previous example, if you cast numeric values to a timestamp

/// with timezone, the cast kernel will not change the underlying values

/// but display and other functions will interpret them as being in the provided timezone.

///

/// ```

/// # use arrow_array::Int64Array;

/// # use arrow_array::types::TimestampSecondType;

/// # use arrow_cast::{cast, display};

/// # use arrow_array::cast::AsArray;

/// # use arrow_schema::{DataType, TimeUnit};

/// // can use "Americas/New_York" if chrono-tz feature is enabled, here use offset based timezone

/// let data_type = DataType::Timestamp(TimeUnit::Second, Some("-05:00".into()));

/// let a = Int64Array::from(vec![1_000_000_000, 2_000_000_000, 3_000_000_000]);

/// let b = cast(&a, &data_type).unwrap();

/// let b = b.as_primitive::<TimestampSecondType>(); // downcast to result type

/// assert_eq!(2_000_000_000, b.value(1)); // values are still the same

/// // displayed in the target timezone (note the offset -05:00)

/// assert_eq!("2033-05-17T22:33:20-05:00", display::array_value_to_string(&b, 1).unwrap());

/// ```

/// # Casting timestamps without timezone to timestamps with timezone

///

/// When casting from a timestamp without timezone to a timestamp with

/// timezone, the cast kernel interprets the timestamp values as being in

/// the destination timezone and then adjusts the underlying value to UTC as required

///

/// However, note that when casting from a timestamp with timezone BACK to a

/// timestamp without timezone the cast kernel does not adjust the values.

///

/// Thus round trip casting a timestamp without timezone to a timestamp with

/// timezone and back to a timestamp without timezone results in different

/// values than the starting values.

///

/// ```

/// # use arrow_array::Int64Array;

/// # use arrow_array::types::{TimestampSecondType};

/// # use arrow_cast::{cast, display};

/// # use arrow_array::cast::AsArray;

/// # use arrow_schema::{DataType, TimeUnit};

/// let data_type  = DataType::Timestamp(TimeUnit::Second, None);

/// let data_type_tz = DataType::Timestamp(TimeUnit::Second, Some("-05:00".into()));

/// let a = Int64Array::from(vec![1_000_000_000, 2_000_000_000, 3_000_000_000]);

/// let b = cast(&a, &data_type).unwrap(); // cast to timestamp without timezone

/// let b = b.as_primitive::<TimestampSecondType>(); // downcast to result type

/// assert_eq!(2_000_000_000, b.value(1)); // values are still the same

/// // displayed without a timezone (note lack of offset or Z)

/// assert_eq!("2033-05-18T03:33:20", display::array_value_to_string(&b, 1).unwrap());

///

/// // Convert timestamps without a timezone to timestamps with a timezone

/// let c = cast(&b, &data_type_tz).unwrap();

/// let c = c.as_primitive::<TimestampSecondType>(); // downcast to result type

/// assert_eq!(2_000_018_000, c.value(1)); // value has been adjusted by offset

/// // displayed with the target timezone offset (-05:00)

/// assert_eq!("2033-05-18T03:33:20-05:00", display::array_value_to_string(&c, 1).unwrap());

///

/// // Convert from timestamp with timezone back to timestamp without timezone

/// let d = cast(&c, &data_type).unwrap();

/// let d = d.as_primitive::<TimestampSecondType>(); // downcast to result type

/// assert_eq!(2_000_018_000, d.value(1)); // value has not been adjusted

/// // NOTE: the timestamp is adjusted (08:33:20 instead of 03:33:20 as in previous example)

/// assert_eq!("2033-05-18T08:33:20", display::array_value_to_string(&d, 1).unwrap());

/// ```

pub fn cast_with_options(

    array: &dyn Array,

    to_type: &DataType,

    cast_options: &CastOptions,

) -> Result<ArrayRef, ArrowError> {

    use DataType::*;

    let from_type = array.data_type();

    // clone array if types are the same

    if from_type == to_type {

        return Ok(make_array(array.to_data()));

    }

    match (from_type, to_type) {

        (

            Null,

            Boolean

            | Int8

            | UInt8

            | Int16

            | UInt16

            | Int32

            | UInt32

            | Float32

            | Date32

            | Time32(_)

            | Int64

            | UInt64

            | Float64

            | Date64

            | Timestamp(_, _)

            | Time64(_)

            | Duration(_)

            | Interval(_)

            | FixedSizeBinary(_)

            | Binary

            | Utf8

            | LargeBinary

            | LargeUtf8

            | BinaryView

            | Utf8View

            | List(_)

            | LargeList(_)

            | FixedSizeList(_, _)

            | Struct(_)

            | Map(_, _)

            | Dictionary(_, _),

        ) => Ok(new_null_array(to_type, array.len())),

        (Dictionary(index_type, _), _) => match **index_type {

            Int8 => dictionary_cast::<Int8Type>(array, to_type, cast_options),

            Int16 => dictionary_cast::<Int16Type>(array, to_type, cast_options),

            Int32 => dictionary_cast::<Int32Type>(array, to_type, cast_options),

            Int64 => dictionary_cast::<Int64Type>(array, to_type, cast_options),

            UInt8 => dictionary_cast::<UInt8Type>(array, to_type, cast_options),

            UInt16 => dictionary_cast::<UInt16Type>(array, to_type, cast_options),

            UInt32 => dictionary_cast::<UInt32Type>(array, to_type, cast_options),

            UInt64 => dictionary_cast::<UInt64Type>(array, to_type, cast_options),

            _ => Err(ArrowError::CastError(format!(

                "Casting from dictionary type {from_type:?} to {to_type:?} not supported",

            ))),

        },

        (_, Dictionary(index_type, value_type)) => match **index_type {

            Int8 => cast_to_dictionary::<Int8Type>(array, value_type, cast_options),

            Int16 => cast_to_dictionary::<Int16Type>(array, value_type, cast_options),

            Int32 => cast_to_dictionary::<Int32Type>(array, value_type, cast_options),

            Int64 => cast_to_dictionary::<Int64Type>(array, value_type, cast_options),

            UInt8 => cast_to_dictionary::<UInt8Type>(array, value_type, cast_options),

            UInt16 => cast_to_dictionary::<UInt16Type>(array, value_type, cast_options),

            UInt32 => cast_to_dictionary::<UInt32Type>(array, value_type, cast_options),

            UInt64 => cast_to_dictionary::<UInt64Type>(array, value_type, cast_options),

            _ => Err(ArrowError::CastError(format!(

                "Casting from type {from_type:?} to dictionary type {to_type:?} not supported",

            ))),

        },

        (List(_), List(to)) => cast_list_values::<i32>(array, to, cast_options),

        (LargeList(_), LargeList(to)) => cast_list_values::<i64>(array, to, cast_options),

        (List(_), LargeList(list_to)) => cast_list::<i32, i64>(array, list_to, cast_options),

        (LargeList(_), List(list_to)) => cast_list::<i64, i32>(array, list_to, cast_options),

        (List(_), FixedSizeList(field, size)) => {

            let array = array.as_list::<i32>();

            cast_list_to_fixed_size_list::<i32>(array, field, *size, cast_options)

        }

        (LargeList(_), FixedSizeList(field, size)) => {

            let array = array.as_list::<i64>();

            cast_list_to_fixed_size_list::<i64>(array, field, *size, cast_options)

        }

        (List(_) | LargeList(_), _) => match to_type {

            Utf8 => value_to_string::<i32>(array, cast_options),

            LargeUtf8 => value_to_string::<i64>(array, cast_options),

            _ => Err(ArrowError::CastError(

                "Cannot cast list to non-list data types".to_string(),

            )),

        },

        (FixedSizeList(list_from, size), List(list_to)) => {

            if list_to.data_type() != list_from.data_type() {

                // To transform inner type, can first cast to FSL with new inner type.

                let fsl_to = DataType::FixedSizeList(list_to.clone(), *size);

                let array = cast_with_options(array, &fsl_to, cast_options)?;

                cast_fixed_size_list_to_list::<i32>(array.as_ref())

            } else {

                cast_fixed_size_list_to_list::<i32>(array)

            }

        }

        (FixedSizeList(list_from, size), LargeList(list_to)) => {

            if list_to.data_type() != list_from.data_type() {

                // To transform inner type, can first cast to FSL with new inner type.

                let fsl_to = DataType::FixedSizeList(list_to.clone(), *size);

                let array = cast_with_options(array, &fsl_to, cast_options)?;

                cast_fixed_size_list_to_list::<i64>(array.as_ref())

            } else {

                cast_fixed_size_list_to_list::<i64>(array)

            }

        }

        (FixedSizeList(_, size_from), FixedSizeList(list_to, size_to)) => {

            if size_from != size_to {

                return Err(ArrowError::CastError(

                    "cannot cast fixed-size-list to fixed-size-list with different size".into(),

                ));

            }

            let array = array.as_any().downcast_ref::<FixedSizeListArray>().unwrap();

            let values = cast_with_options(array.values(), list_to.data_type(), cast_options)?;

            Ok(Arc::new(FixedSizeListArray::try_new(

                list_to.clone(),

                *size_from,

                values,

                array.nulls().cloned(),

            )?))

        }

        (_, List(ref to)) => cast_values_to_list::<i32>(array, to, cast_options),

        (_, LargeList(ref to)) => cast_values_to_list::<i64>(array, to, cast_options),

        (_, FixedSizeList(ref to, size)) if *size == 1 => {

            cast_values_to_fixed_size_list(array, to, *size, cast_options)

        }

        (FixedSizeList(_, size), _) if *size == 1 => {

            cast_single_element_fixed_size_list_to_values(array, to_type, cast_options)

        }

        (Map(_, ordered1), Map(_, ordered2)) if ordered1 == ordered2 => {

            cast_map_values(array.as_map(), to_type, cast_options, ordered1.to_owned())

        }

        // Decimal to decimal, same width

        (Decimal32(p1, s1), Decimal32(p2, s2)) => {

            cast_decimal_to_decimal_same_type::<Decimal32Type>(

                array.as_primitive(),

                *p1,

                *s1,

                *p2,

                *s2,

                cast_options,

            )

        }

        (Decimal64(p1, s1), Decimal64(p2, s2)) => {

            cast_decimal_to_decimal_same_type::<Decimal64Type>(

                array.as_primitive(),

                *p1,

                *s1,

                *p2,

                *s2,

                cast_options,

            )

        }

        (Decimal128(p1, s1), Decimal128(p2, s2)) => {

            cast_decimal_to_decimal_same_type::<Decimal128Type>(

                array.as_primitive(),

                *p1,

                *s1,

                *p2,

                *s2,

                cast_options,

            )

        }

        (Decimal256(p1, s1), Decimal256(p2, s2)) => {

            cast_decimal_to_decimal_same_type::<Decimal256Type>(

                array.as_primitive(),

                *p1,

                *s1,

                *p2,

                *s2,

                cast_options,

            )

        }

        // Decimal to decimal, different width

        (Decimal32(p1, s1), Decimal64(p2, s2)) => {

            cast_decimal_to_decimal::<Decimal32Type, Decimal64Type>(

                array.as_primitive(),

                *p1,

                *s1,

                *p2,

                *s2,

                cast_options,

            )

        }

        (Decimal32(p1, s1), Decimal128(p2, s2)) => {

            cast_decimal_to_decimal::<Decimal32Type, Decimal128Type>(

                array.as_primitive(),