use std::collections::{HashMap, HashSet};
use std::str::FromStr as _;
use std::time::Instant;

use chrono::{NaiveDateTime, Timelike};
use common::counter::hardware_accumulator::HwMeasurementAcc;
use common::counter::hardware_counter::HardwareCounterCell;
use itertools::Itertools;
use segment::common::operation_error::OperationError;
use segment::data_types::index::{
    BoolIndexType, DatetimeIndexType, FloatIndexType, GeoIndexType, IntegerIndexType,
    KeywordIndexType, TextIndexType, UuidIndexType,
};
use segment::data_types::{facets as segment_facets, vectors as segment_vectors};
use segment::types::{default_quantization_ignore_value, DateTimePayloadType, FloatPayloadType};
use segment::vector_storage::query as segment_query;
use sparse::common::sparse_vector::validate_sparse_vector_impl;
use tonic::Status;
use uuid::Uuid;

use super::qdrant::raw_query::RawContextPair;
use super::qdrant::{
    raw_query, start_from, BinaryQuantization, BoolIndexParams, CompressionRatio,
    DatetimeIndexParams, DatetimeRange, Direction, FacetHit, FacetHitInternal, FacetValue,
    FacetValueInternal, FieldType, FloatIndexParams, GeoIndexParams, GeoLineString, GroupId,
    HardwareUsage, HasVectorCondition, KeywordIndexParams, LookupLocation, MultiVectorComparator,
    MultiVectorConfig, OrderBy, OrderValue, Range, RawVector, RecommendStrategy, RetrievedPoint,
    SearchMatrixPair, SearchPointGroups, SearchPoints, ShardKeySelector, SparseIndices, StartFrom,
    UuidIndexParams, VectorsOutput, WithLookup,
};
use crate::conversions::json;
use crate::grpc::qdrant::condition::ConditionOneOf;
use crate::grpc::qdrant::payload_index_params::IndexParams;
use crate::grpc::qdrant::point_id::PointIdOptions;
use crate::grpc::qdrant::r#match::MatchValue;
use crate::grpc::qdrant::with_payload_selector::SelectorOptions;
use crate::grpc::qdrant::{
    shard_key, with_vectors_selector, CollectionDescription, CollectionOperationResponse,
    Condition, Distance, FieldCondition, Filter, GeoBoundingBox, GeoPoint, GeoPolygon, GeoRadius,
    HasIdCondition, HealthCheckReply, HnswConfigDiff, IntegerIndexParams, IsEmptyCondition,
    IsNullCondition, ListCollectionsResponse, Match, MinShould, NamedVectors, NestedCondition,
    PayloadExcludeSelector, PayloadIncludeSelector, PayloadIndexParams, PayloadSchemaInfo,
    PayloadSchemaType, PointId, PointStruct, PointsOperationResponse,
    PointsOperationResponseInternal, ProductQuantization, QuantizationConfig,
    QuantizationSearchParams, QuantizationType, RepeatedIntegers, RepeatedStrings,
    ScalarQuantization, ScoredPoint, SearchParams, ShardKey, StrictModeConfig, TextIndexParams,
    TokenizerType, UpdateResult, UpdateResultInternal, ValuesCount, VectorsSelector,
    WithPayloadSelector, WithVectorsSelector,
};
use crate::rest::models::{CollectionsResponse, VersionInfo};
use crate::rest::schema as rest;

pub fn convert_shard_key_to_grpc(value: segment::types::ShardKey) -> ShardKey {
    match value {
        segment::types::ShardKey::Keyword(keyword) => ShardKey {
            key: Some(shard_key::Key::Keyword(keyword)),
        },
        segment::types::ShardKey::Number(number) => ShardKey {
            key: Some(shard_key::Key::Number(number)),
        },
    }
}

pub fn convert_shard_key_from_grpc(value: ShardKey) -> Option<segment::types::ShardKey> {
    match value.key {
        None => None,
        Some(key) => match key {
            shard_key::Key::Keyword(keyword) => Some(segment::types::ShardKey::Keyword(keyword)),
            shard_key::Key::Number(number) => Some(segment::types::ShardKey::Number(number)),
        },
    }
}

pub fn convert_shard_key_from_grpc_opt(
    value: Option<ShardKey>,
) -> Option<segment::types::ShardKey> {
    match value {
        None => None,
        Some(key) => match key.key {
            None => None,
            Some(key) => match key {
                shard_key::Key::Keyword(keyword) => {
                    Some(segment::types::ShardKey::Keyword(keyword))
                }
                shard_key::Key::Number(number) => Some(segment::types::ShardKey::Number(number)),
            },
        },
    }
}
impl From<ShardKeySelector> for rest::ShardKeySelector {
    fn from(value: ShardKeySelector) -> Self {
        let shard_keys: Vec<_> = value
            .shard_keys
            .into_iter()
            .filter_map(convert_shard_key_from_grpc)
            .collect();

        if shard_keys.len() == 1 {
            rest::ShardKeySelector::ShardKey(shard_keys.into_iter().next().unwrap())
        } else {
            rest::ShardKeySelector::ShardKeys(shard_keys)
        }
    }
}

impl From<VersionInfo> for HealthCheckReply {
    fn from(info: VersionInfo) -> Self {
        HealthCheckReply {
            title: info.title,
            version: info.version,
            commit: info.commit,
        }
    }
}

impl From<(Instant, CollectionsResponse)> for ListCollectionsResponse {
    fn from(value: (Instant, CollectionsResponse)) -> Self {
        let (timing, response) = value;
        let collections = response
            .collections
            .into_iter()
            .map(|desc| CollectionDescription { name: desc.name })
            .collect::<Vec<_>>();
        Self {
            collections,
            time: timing.elapsed().as_secs_f64(),
        }
    }
}

impl From<segment::data_types::index::TokenizerType> for TokenizerType {
    fn from(tokenizer_type: segment::data_types::index::TokenizerType) -> Self {
        match tokenizer_type {
            segment::data_types::index::TokenizerType::Prefix => TokenizerType::Prefix,
            segment::data_types::index::TokenizerType::Whitespace => TokenizerType::Whitespace,
            segment::data_types::index::TokenizerType::Multilingual => TokenizerType::Multilingual,
            segment::data_types::index::TokenizerType::Word => TokenizerType::Word,
        }
    }
}

impl From<segment::data_types::index::KeywordIndexParams> for PayloadIndexParams {
    fn from(params: segment::data_types::index::KeywordIndexParams) -> Self {
        PayloadIndexParams {
            index_params: Some(IndexParams::KeywordIndexParams(KeywordIndexParams {
                is_tenant: params.is_tenant,
                on_disk: params.on_disk,
            })),
        }
    }
}

impl From<segment::data_types::index::IntegerIndexParams> for PayloadIndexParams {
    fn from(params: segment::data_types::index::IntegerIndexParams) -> Self {
        PayloadIndexParams {
            index_params: Some(IndexParams::IntegerIndexParams(IntegerIndexParams {
                lookup: params.lookup,
                range: params.range,
                on_disk: params.on_disk,
                is_principal: params.is_principal,
            })),
        }
    }
}

impl From<segment::data_types::index::FloatIndexParams> for PayloadIndexParams {
    fn from(params: segment::data_types::index::FloatIndexParams) -> Self {
        PayloadIndexParams {
            index_params: Some(IndexParams::FloatIndexParams(FloatIndexParams {
                on_disk: params.on_disk,
                is_principal: params.is_principal,
            })),
        }
    }
}

impl From<segment::data_types::index::GeoIndexParams> for PayloadIndexParams {
    fn from(params: segment::data_types::index::GeoIndexParams) -> Self {
        PayloadIndexParams {
            index_params: Some(IndexParams::GeoIndexParams(GeoIndexParams {
                on_disk: params.on_disk,
            })),
        }
    }
}

impl From<segment::data_types::index::TextIndexParams> for PayloadIndexParams {
    fn from(params: segment::data_types::index::TextIndexParams) -> Self {
        let tokenizer = TokenizerType::from(params.tokenizer);
        PayloadIndexParams {
            index_params: Some(IndexParams::TextIndexParams(TextIndexParams {
                tokenizer: tokenizer as i32,
                lowercase: params.lowercase,
                min_token_len: params.min_token_len.map(|x| x as u64),
                max_token_len: params.max_token_len.map(|x| x as u64),
                on_disk: params.on_disk,
            })),
        }
    }
}

impl From<segment::data_types::index::BoolIndexParams> for PayloadIndexParams {
    fn from(_params: segment::data_types::index::BoolIndexParams) -> Self {
        PayloadIndexParams {
            index_params: Some(IndexParams::BoolIndexParams(BoolIndexParams {})),
        }
    }
}

impl From<segment::data_types::index::UuidIndexParams> for PayloadIndexParams {
    fn from(params: segment::data_types::index::UuidIndexParams) -> Self {
        PayloadIndexParams {
            index_params: Some(IndexParams::UuidIndexParams(UuidIndexParams {
                is_tenant: params.is_tenant,
                on_disk: params.on_disk,
            })),
        }
    }
}

impl From<segment::data_types::index::DatetimeIndexParams> for PayloadIndexParams {
    fn from(params: segment::data_types::index::DatetimeIndexParams) -> Self {
        PayloadIndexParams {
            index_params: Some(IndexParams::DatetimeIndexParams(DatetimeIndexParams {
                on_disk: params.on_disk,
                is_principal: params.is_principal,
            })),
        }
    }
}

impl From<segment::types::PayloadIndexInfo> for PayloadSchemaInfo {
    fn from(schema: segment::types::PayloadIndexInfo) -> Self {
        PayloadSchemaInfo {
            data_type: PayloadSchemaType::from(schema.data_type) as i32,
            params: schema.params.map(|p| p.into()),
            points: Some(schema.points as u64),
        }
    }
}

impl From<segment::types::PayloadSchemaType> for PayloadSchemaType {
    fn from(schema_type: segment::types::PayloadSchemaType) -> Self {
        match schema_type {
            segment::types::PayloadSchemaType::Keyword => PayloadSchemaType::Keyword,
            segment::types::PayloadSchemaType::Integer => PayloadSchemaType::Integer,
            segment::types::PayloadSchemaType::Float => PayloadSchemaType::Float,
            segment::types::PayloadSchemaType::Geo => PayloadSchemaType::Geo,
            segment::types::PayloadSchemaType::Text => PayloadSchemaType::Text,
            segment::types::PayloadSchemaType::Bool => PayloadSchemaType::Bool,
            segment::types::PayloadSchemaType::Datetime => PayloadSchemaType::Datetime,
            segment::types::PayloadSchemaType::Uuid => PayloadSchemaType::Uuid,
        }
    }
}

impl From<segment::types::PayloadSchemaType> for FieldType {
    fn from(schema_type: segment::types::PayloadSchemaType) -> Self {
        match schema_type {
            segment::types::PayloadSchemaType::Keyword => FieldType::Keyword,
            segment::types::PayloadSchemaType::Integer => FieldType::Integer,
            segment::types::PayloadSchemaType::Float => FieldType::Float,
            segment::types::PayloadSchemaType::Geo => FieldType::Geo,
            segment::types::PayloadSchemaType::Text => FieldType::Text,
            segment::types::PayloadSchemaType::Bool => FieldType::Bool,
            segment::types::PayloadSchemaType::Datetime => FieldType::Datetime,
            segment::types::PayloadSchemaType::Uuid => FieldType::Uuid,
        }
    }
}

impl TryFrom<TokenizerType> for segment::data_types::index::TokenizerType {
    type Error = Status;
    fn try_from(tokenizer_type: TokenizerType) -> Result<Self, Self::Error> {
        match tokenizer_type {
            TokenizerType::Unknown => Err(Status::invalid_argument("unknown tokenizer type")),
            TokenizerType::Prefix => Ok(segment::data_types::index::TokenizerType::Prefix),
            TokenizerType::Multilingual => {
                Ok(segment::data_types::index::TokenizerType::Multilingual)
            }
            TokenizerType::Whitespace => Ok(segment::data_types::index::TokenizerType::Whitespace),
            TokenizerType::Word => Ok(segment::data_types::index::TokenizerType::Word),
        }
    }
}

impl From<segment::types::PayloadSchemaParams> for PayloadIndexParams {
    fn from(params: segment::types::PayloadSchemaParams) -> Self {
        match params {
            segment::types::PayloadSchemaParams::Keyword(p) => p.into(),
            segment::types::PayloadSchemaParams::Integer(p) => p.into(),
            segment::types::PayloadSchemaParams::Float(p) => p.into(),
            segment::types::PayloadSchemaParams::Geo(p) => p.into(),
            segment::types::PayloadSchemaParams::Text(p) => p.into(),
            segment::types::PayloadSchemaParams::Bool(p) => p.into(),
            segment::types::PayloadSchemaParams::Datetime(p) => p.into(),
            segment::types::PayloadSchemaParams::Uuid(p) => p.into(),
        }
    }
}

impl TryFrom<KeywordIndexParams> for segment::data_types::index::KeywordIndexParams {
    type Error = Status;
    fn try_from(params: KeywordIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::KeywordIndexParams {
            r#type: KeywordIndexType::Keyword,
            is_tenant: params.is_tenant,
            on_disk: params.on_disk,
        })
    }
}

impl TryFrom<IntegerIndexParams> for segment::data_types::index::IntegerIndexParams {
    type Error = Status;
    fn try_from(params: IntegerIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::IntegerIndexParams {
            r#type: IntegerIndexType::Integer,
            lookup: params.lookup,
            range: params.range,
            is_principal: params.is_principal,
            on_disk: params.on_disk,
        })
    }
}

impl TryFrom<FloatIndexParams> for segment::data_types::index::FloatIndexParams {
    type Error = Status;
    fn try_from(params: FloatIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::FloatIndexParams {
            r#type: FloatIndexType::Float,
            on_disk: params.on_disk,
            is_principal: params.is_principal,
        })
    }
}

impl TryFrom<GeoIndexParams> for segment::data_types::index::GeoIndexParams {
    type Error = Status;
    fn try_from(params: GeoIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::GeoIndexParams {
            r#type: GeoIndexType::Geo,
            on_disk: params.on_disk,
        })
    }
}

impl TryFrom<TextIndexParams> for segment::data_types::index::TextIndexParams {
    type Error = Status;
    fn try_from(params: TextIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::TextIndexParams {
            r#type: TextIndexType::Text,
            tokenizer: TokenizerType::try_from(params.tokenizer)
                .map(|x| x.try_into())
                .unwrap_or_else(|_| Err(Status::invalid_argument("unknown tokenizer type")))?,
            lowercase: params.lowercase,
            min_token_len: params.min_token_len.map(|x| x as usize),
            max_token_len: params.max_token_len.map(|x| x as usize),
            on_disk: params.on_disk,
        })
    }
}

impl TryFrom<BoolIndexParams> for segment::data_types::index::BoolIndexParams {
    type Error = Status;
    fn try_from(_params: BoolIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::BoolIndexParams {
            r#type: BoolIndexType::Bool,
        })
    }
}

impl TryFrom<DatetimeIndexParams> for segment::data_types::index::DatetimeIndexParams {
    type Error = Status;
    fn try_from(params: DatetimeIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::DatetimeIndexParams {
            r#type: DatetimeIndexType::Datetime,
            on_disk: params.on_disk,
            is_principal: params.is_principal,
        })
    }
}

impl TryFrom<UuidIndexParams> for segment::data_types::index::UuidIndexParams {
    type Error = Status;
    fn try_from(params: UuidIndexParams) -> Result<Self, Self::Error> {
        Ok(segment::data_types::index::UuidIndexParams {
            r#type: UuidIndexType::Uuid,
            is_tenant: params.is_tenant,
            on_disk: params.on_disk,
        })
    }
}

impl TryFrom<IndexParams> for segment::types::PayloadSchemaParams {
    type Error = Status;

    fn try_from(value: IndexParams) -> Result<Self, Self::Error> {
        Ok(match value {
            IndexParams::KeywordIndexParams(p) => {
                segment::types::PayloadSchemaParams::Keyword(p.try_into()?)
            }
            IndexParams::IntegerIndexParams(p) => {
                segment::types::PayloadSchemaParams::Integer(p.try_into()?)
            }
            IndexParams::FloatIndexParams(p) => {
                segment::types::PayloadSchemaParams::Float(p.try_into()?)
            }
            IndexParams::GeoIndexParams(p) => {
                segment::types::PayloadSchemaParams::Geo(p.try_into()?)
            }
            IndexParams::TextIndexParams(p) => {
                segment::types::PayloadSchemaParams::Text(p.try_into()?)
            }
            IndexParams::BoolIndexParams(p) => {
                segment::types::PayloadSchemaParams::Bool(p.try_into()?)
            }
            IndexParams::DatetimeIndexParams(p) => {
                segment::types::PayloadSchemaParams::Datetime(p.try_into()?)
            }
            IndexParams::UuidIndexParams(p) => {
                segment::types::PayloadSchemaParams::Uuid(p.try_into()?)
            }
        })
    }
}

impl TryFrom<PayloadSchemaInfo> for segment::types::PayloadIndexInfo {
    type Error = Status;

    fn try_from(schema: PayloadSchemaInfo) -> Result<Self, Self::Error> {
        let data_type = match PayloadSchemaType::try_from(schema.data_type) {
            Err(_) => {
                return Err(Status::invalid_argument(
                    "Malformed payload schema".to_string(),
                ));
            }
            Ok(data_type) => match data_type {
                PayloadSchemaType::Keyword => segment::types::PayloadSchemaType::Keyword,
                PayloadSchemaType::Integer => segment::types::PayloadSchemaType::Integer,
                PayloadSchemaType::Float => segment::types::PayloadSchemaType::Float,
                PayloadSchemaType::Geo => segment::types::PayloadSchemaType::Geo,
                PayloadSchemaType::Text => segment::types::PayloadSchemaType::Text,
                PayloadSchemaType::Bool => segment::types::PayloadSchemaType::Bool,
                PayloadSchemaType::Datetime => segment::types::PayloadSchemaType::Datetime,
                PayloadSchemaType::UnknownType => {
                    return Err(Status::invalid_argument(
                        "Malformed payload schema".to_string(),
                    ));
                }
                PayloadSchemaType::Uuid => segment::types::PayloadSchemaType::Uuid,
            },
        };
        let params = match schema.params {
            None => None,
            Some(PayloadIndexParams { index_params: None }) => None,
            Some(PayloadIndexParams {
                index_params: Some(index_params),
            }) => Some(index_params.try_into()?),
        };

        Ok(segment::types::PayloadIndexInfo {
            data_type,
            params,
            points: schema.points.unwrap_or(0) as usize,
        })
    }
}

impl From<(Instant, bool)> for CollectionOperationResponse {
    fn from(value: (Instant, bool)) -> Self {
        let (timing, result) = value;
        CollectionOperationResponse {
            result,
            time: timing.elapsed().as_secs_f64(),
        }
    }
}

impl From<segment::types::GeoPoint> for GeoPoint {
    fn from(geo: segment::types::GeoPoint) -> Self {
        Self {
            lon: geo.lon,
            lat: geo.lat,
        }
    }
}

impl TryFrom<WithPayloadSelector> for segment::types::WithPayloadInterface {
    type Error = Status;

    fn try_from(value: WithPayloadSelector) -> Result<Self, Self::Error> {
        match value.selector_options {
            Some(options) => Ok(match options {
                SelectorOptions::Enable(flag) => segment::types::WithPayloadInterface::Bool(flag),
                SelectorOptions::Exclude(s) => segment::types::PayloadSelectorExclude::new(
                    s.fields
                        .iter()
                        .map(|i| json::json_path_from_proto(i))
                        .collect::<Result<_, _>>()?,
                )
                .into(),
                SelectorOptions::Include(s) => segment::types::PayloadSelectorInclude::new(
                    s.fields
                        .iter()
                        .map(|i| json::json_path_from_proto(i))
                        .collect::<Result<_, _>>()?,
                )
                .into(),
            }),
            _ => Err(Status::invalid_argument("No PayloadSelector".to_string())),
        }
    }
}

impl From<segment::types::WithPayloadInterface> for WithPayloadSelector {
    fn from(value: segment::types::WithPayloadInterface) -> Self {
        let selector_options = match value {
            segment::types::WithPayloadInterface::Bool(flag) => SelectorOptions::Enable(flag),
            segment::types::WithPayloadInterface::Fields(fields) => {
                SelectorOptions::Include(PayloadIncludeSelector {
                    fields: fields.iter().map(|f| f.to_string()).collect(),
                })
            }
            segment::types::WithPayloadInterface::Selector(selector) => match selector {
                segment::types::PayloadSelector::Include(s) => {
                    SelectorOptions::Include(PayloadIncludeSelector {
                        fields: s.include.iter().map(|f| f.to_string()).collect(),
                    })
                }
                segment::types::PayloadSelector::Exclude(s) => {
                    SelectorOptions::Exclude(PayloadExcludeSelector {
                        fields: s.exclude.iter().map(|f| f.to_string()).collect(),
                    })
                }
            },
        };
        WithPayloadSelector {
            selector_options: Some(selector_options),
        }
    }
}

impl From<QuantizationSearchParams> for segment::types::QuantizationSearchParams {
    fn from(params: QuantizationSearchParams) -> Self {
        Self {
            ignore: params.ignore.unwrap_or(default_quantization_ignore_value()),
            rescore: params.rescore,
            oversampling: params.oversampling,
        }
    }
}

impl From<segment::types::QuantizationSearchParams> for QuantizationSearchParams {
    fn from(params: segment::types::QuantizationSearchParams) -> Self {
        Self {
            ignore: Some(params.ignore),
            rescore: params.rescore,
            oversampling: params.oversampling,
        }
    }
}

impl From<SearchParams> for segment::types::SearchParams {
    fn from(params: SearchParams) -> Self {
        Self {
            hnsw_ef: params.hnsw_ef.map(|x| x as usize),
            exact: params.exact.unwrap_or(false),
            quantization: params.quantization.map(|q| q.into()),
            indexed_only: params.indexed_only.unwrap_or(false),
        }
    }
}

impl From<segment::types::SearchParams> for SearchParams {
    fn from(params: segment::types::SearchParams) -> Self {
        Self {
            hnsw_ef: params.hnsw_ef.map(|x| x as u64),
            exact: Some(params.exact),
            quantization: params.quantization.map(|q| q.into()),
            indexed_only: Some(params.indexed_only),
        }
    }
}

impl From<segment::types::PointIdType> for PointId {
    fn from(point_id: segment::types::PointIdType) -> Self {
        PointId {
            point_id_options: Some(match point_id {
                segment::types::PointIdType::NumId(num) => PointIdOptions::Num(num),
                segment::types::PointIdType::Uuid(uuid) => PointIdOptions::Uuid(uuid.to_string()),
            }),
        }
    }
}

impl TryFrom<PointStruct> for rest::PointStruct {
    type Error = Status;

    fn try_from(value: PointStruct) -> Result<Self, Self::Error> {
        let PointStruct {
            id,
            vectors,
            payload,
        } = value;

        // empty payload means None in PointStruct
        let converted_payload = if payload.is_empty() {
            None
        } else {
            Some(json::proto_to_payloads(payload)?)
        };

        let vector_struct = match vectors {
            None => return Err(Status::invalid_argument("Expected some vectors")),
            Some(vectors) => rest::VectorStruct::try_from(vectors)?,
        };

        Ok(Self {
            id: id
                .ok_or_else(|| Status::invalid_argument("Empty ID is not allowed"))?
                .try_into()?,
            vector: vector_struct,
            payload: converted_payload,
        })
    }
}

impl TryFrom<rest::Record> for RetrievedPoint {
    type Error = OperationError;
    fn try_from(record: rest::Record) -> Result<Self, Self::Error> {
        let retrieved_point = Self {
            id: Some(PointId::from(record.id)),
            payload: record
                .payload
                .map(json::payload_to_proto)
                .unwrap_or_default(),
            vectors: record.vector.map(VectorsOutput::try_from).transpose()?,
            shard_key: record.shard_key.map(convert_shard_key_to_grpc),
            order_value: record.order_value.map(From::from),
        };
        Ok(retrieved_point)
    }
}

impl From<segment::data_types::order_by::OrderValue> for OrderValue {
    fn from(value: segment::data_types::order_by::OrderValue) -> Self {
        use segment::data_types::order_by as segment;

        use crate::grpc::qdrant::order_value::Variant;

        let variant = match value {
            segment::OrderValue::Float(value) => Variant::Float(value),
            segment::OrderValue::Int(value) => Variant::Int(value),
        };

        Self {
            variant: Some(variant),
        }
    }
}

impl TryFrom<OrderValue> for segment::data_types::order_by::OrderValue {
    type Error = Status;

    fn try_from(value: OrderValue) -> Result<Self, Self::Error> {
        use segment::data_types::order_by as segment;

        use crate::grpc::qdrant::order_value::Variant;

        let variant = value.variant.ok_or_else(|| {
            Status::invalid_argument("OrderedValue should have a variant".to_string())
        })?;

        let value = match variant {
            Variant::Float(value) => segment::OrderValue::Float(value),
            Variant::Int(value) => segment::OrderValue::Int(value),
        };

        Ok(value)
    }
}

impl From<segment::types::ScoredPoint> for ScoredPoint {
    fn from(point: segment::types::ScoredPoint) -> Self {
        Self {
            id: Some(PointId::from(point.id)),
            payload: point
                .payload
                .map(json::payload_to_proto)
                .unwrap_or_default(),
            score: point.score,
            version: point.version,
            vectors: point.vector.map(VectorsOutput::from),
            shard_key: point.shard_key.map(convert_shard_key_to_grpc),
            order_value: point.order_value.map(OrderValue::from),
        }
    }
}

impl TryFrom<crate::rest::ScoredPoint> for ScoredPoint {
    type Error = OperationError;
    fn try_from(point: crate::rest::ScoredPoint) -> Result<Self, Self::Error> {
        Ok(Self {
            id: Some(PointId::from(point.id)),
            payload: point
                .payload
                .map(json::payload_to_proto)
                .unwrap_or_default(),
            score: point.score,
            version: point.version,
            vectors: point.vector.map(VectorsOutput::try_from).transpose()?,
            shard_key: point.shard_key.map(convert_shard_key_to_grpc),
            order_value: point.order_value.map(OrderValue::from),
        })
    }
}

impl From<segment::data_types::groups::GroupId> for GroupId {
    fn from(key: segment::data_types::groups::GroupId) -> Self {
        match key {
            segment::data_types::groups::GroupId::String(str) => Self {
                kind: Some(crate::grpc::qdrant::group_id::Kind::StringValue(str)),
            },
            segment::data_types::groups::GroupId::NumberU64(n) => Self {
                kind: Some(crate::grpc::qdrant::group_id::Kind::UnsignedValue(n)),
            },
            segment::data_types::groups::GroupId::NumberI64(n) => Self {
                kind: Some(crate::grpc::qdrant::group_id::Kind::IntegerValue(n)),
            },
        }
    }
}

impl TryFrom<NamedVectors> for HashMap<String, segment_vectors::VectorInternal> {
    type Error = Status;

    fn try_from(vectors: NamedVectors) -> Result<Self, Self::Error> {
        vectors
            .vectors
            .into_iter()
            .map(
                |(name, vector)| match segment_vectors::VectorInternal::try_from(vector) {
                    Ok(vector) => Ok((name, vector)),
                    Err(err) => Err(err),
                },
            )
            .collect::<Result<_, _>>()
    }
}

impl From<segment::types::WithVector> for WithVectorsSelector {
    fn from(with_vectors: segment::types::WithVector) -> Self {
        let selector_options = match with_vectors {
            segment::types::WithVector::Bool(enabled) => {
                with_vectors_selector::SelectorOptions::Enable(enabled)
            }
            segment::types::WithVector::Selector(include) => {
                with_vectors_selector::SelectorOptions::Include(VectorsSelector { names: include })
            }
        };
        Self {
            selector_options: Some(selector_options),
        }
    }
}

impl From<WithVectorsSelector> for segment::types::WithVector {
    fn from(with_vectors_selector: WithVectorsSelector) -> Self {
        match with_vectors_selector.selector_options {
            None => Self::default(),
            Some(with_vectors_selector::SelectorOptions::Enable(enabled)) => Self::Bool(enabled),
            Some(with_vectors_selector::SelectorOptions::Include(include)) => {
                Self::Selector(include.names)
            }
        }
    }
}

impl TryFrom<PointId> for segment::types::PointIdType {
    type Error = Status;

    fn try_from(value: PointId) -> Result<Self, Self::Error> {
        match value.point_id_options {
            Some(PointIdOptions::Num(num_id)) => Ok(segment::types::PointIdType::NumId(num_id)),
            Some(PointIdOptions::Uuid(uui_str)) => Uuid::parse_str(&uui_str)
                .map(segment::types::PointIdType::Uuid)
                .map_err(|_err| {
                    Status::invalid_argument(format!("Unable to parse UUID: {uui_str}"))
                }),
            _ => Err(Status::invalid_argument(
                "No ID options provided".to_string(),
            )),
        }
    }
}

impl From<segment::types::ScalarQuantization> for ScalarQuantization {
    fn from(value: segment::types::ScalarQuantization) -> Self {
        let config = value.scalar;
        ScalarQuantization {
            r#type: match config.r#type {
                segment::types::ScalarType::Int8 => {
                    crate::grpc::qdrant::QuantizationType::Int8 as i32
                }
            },
            quantile: config.quantile,
            always_ram: config.always_ram,
        }
    }
}

impl TryFrom<ScalarQuantization> for segment::types::ScalarQuantization {
    type Error = Status;

    fn try_from(value: ScalarQuantization) -> Result<Self, Self::Error> {
        Ok(segment::types::ScalarQuantization {
            scalar: segment::types::ScalarQuantizationConfig {
                r#type: match QuantizationType::try_from(value.r#type).ok() {
                    Some(QuantizationType::Int8) => segment::types::ScalarType::Int8,
                    Some(QuantizationType::UnknownQuantization) | None => {
                        return Err(Status::invalid_argument("Unknown quantization type"));
                    }
                },
                quantile: value.quantile,
                always_ram: value.always_ram,
            },
        })
    }
}

impl From<segment::types::ProductQuantization> for ProductQuantization {
    fn from(value: segment::types::ProductQuantization) -> Self {
        let config = value.product;
        ProductQuantization {
            compression: match config.compression {
                segment::types::CompressionRatio::X4 => CompressionRatio::X4 as i32,
                segment::types::CompressionRatio::X8 => CompressionRatio::X8 as i32,
                segment::types::CompressionRatio::X16 => CompressionRatio::X16 as i32,
                segment::types::CompressionRatio::X32 => CompressionRatio::X32 as i32,
                segment::types::CompressionRatio::X64 => CompressionRatio::X64 as i32,
            },
            always_ram: config.always_ram,
        }
    }
}

impl TryFrom<ProductQuantization> for segment::types::ProductQuantization {
    type Error = Status;

    fn try_from(value: ProductQuantization) -> Result<Self, Self::Error> {
        Ok(segment::types::ProductQuantization {
            product: segment::types::ProductQuantizationConfig {
                compression: match CompressionRatio::try_from(value.compression) {
                    Err(_) => {
                        return Err(Status::invalid_argument(
                            "Unknown compression ratio".to_string(),
                        ));
                    }
                    Ok(CompressionRatio::X4) => segment::types::CompressionRatio::X4,
                    Ok(CompressionRatio::X8) => segment::types::CompressionRatio::X8,
                    Ok(CompressionRatio::X16) => segment::types::CompressionRatio::X16,
                    Ok(CompressionRatio::X32) => segment::types::CompressionRatio::X32,
                    Ok(CompressionRatio::X64) => segment::types::CompressionRatio::X64,
                },
                always_ram: value.always_ram,
            },
        })
    }
}

impl From<segment::types::BinaryQuantization> for BinaryQuantization {
    fn from(value: segment::types::BinaryQuantization) -> Self {
        let config = value.binary;
        BinaryQuantization {
            always_ram: config.always_ram,
        }
    }
}

impl TryFrom<BinaryQuantization> for segment::types::BinaryQuantization {
    type Error = Status;

    fn try_from(value: BinaryQuantization) -> Result<Self, Self::Error> {
        Ok(segment::types::BinaryQuantization {
            binary: segment::types::BinaryQuantizationConfig {
                always_ram: value.always_ram,
            },
        })
    }
}

impl From<segment::types::QuantizationConfig> for QuantizationConfig {
    fn from(value: segment::types::QuantizationConfig) -> Self {
        match value {
            segment::types::QuantizationConfig::Scalar(scalar) => Self {
                quantization: Some(super::qdrant::quantization_config::Quantization::Scalar(
                    scalar.into(),
                )),
            },
            segment::types::QuantizationConfig::Product(product) => Self {
                quantization: Some(super::qdrant::quantization_config::Quantization::Product(
                    product.into(),
                )),
            },
            segment::types::QuantizationConfig::Binary(binary) => Self {
                quantization: Some(super::qdrant::quantization_config::Quantization::Binary(
                    binary.into(),
                )),
            },
        }
    }
}

impl TryFrom<QuantizationConfig> for segment::types::QuantizationConfig {
    type Error = Status;

    fn try_from(value: QuantizationConfig) -> Result<Self, Self::Error> {
        let value = value
            .quantization
            .ok_or_else(|| Status::invalid_argument("Unable to convert quantization config"))?;
        match value {
            super::qdrant::quantization_config::Quantization::Scalar(config) => Ok(
                segment::types::QuantizationConfig::Scalar(config.try_into()?),
            ),
            super::qdrant::quantization_config::Quantization::Product(config) => Ok(
                segment::types::QuantizationConfig::Product(config.try_into()?),
            ),
            super::qdrant::quantization_config::Quantization::Binary(config) => Ok(
                segment::types::QuantizationConfig::Binary(config.try_into()?),
            ),
        }
    }
}

impl From<segment::types::MultiVectorConfig> for MultiVectorConfig {
    fn from(value: segment::types::MultiVectorConfig) -> Self {
        Self {
            comparator: MultiVectorComparator::from(value.comparator) as i32,
        }
    }
}

impl From<segment::types::MultiVectorComparator> for MultiVectorComparator {
    fn from(value: segment::types::MultiVectorComparator) -> Self {
        match value {
            segment::types::MultiVectorComparator::MaxSim => MultiVectorComparator::MaxSim,
        }
    }
}

impl TryFrom<MultiVectorConfig> for segment::types::MultiVectorConfig {
    type Error = Status;

    fn try_from(value: MultiVectorConfig) -> Result<Self, Self::Error> {
        let comparator = MultiVectorComparator::try_from(value.comparator)
            .map_err(|_| Status::invalid_argument("Unknown multi vector comparator"))?;
        Ok(segment::types::MultiVectorConfig {
            comparator: segment::types::MultiVectorComparator::from(comparator),
        })
    }
}

impl From<MultiVectorComparator> for segment::types::MultiVectorComparator {
    fn from(value: MultiVectorComparator) -> Self {
        match value {
            MultiVectorComparator::MaxSim => segment::types::MultiVectorComparator::MaxSim,
        }
    }
}

fn conditions_helper_from_grpc(
    conditions: Vec<Condition>,
) -> Result<Option<Vec<segment::types::Condition>>, tonic::Status> {
    if conditions.is_empty() {
        Ok(None)
    } else {
        let vec = conditions
            .into_iter()
            .map(|c| c.try_into())
            .collect::<Result<_, _>>()?;
        Ok(Some(vec))
    }
}

fn conditions_helper_to_grpc(conditions: Option<Vec<segment::types::Condition>>) -> Vec<Condition> {
    match conditions {
        None => vec![],
        Some(conditions) => {
            if conditions.is_empty() {
                vec![]
            } else {
                conditions
                    .into_iter()
                    .map(Condition::from)
                    .filter(|c| c.condition_one_of.is_some()) // Filter out empty conditions
                    .collect()
            }
        }
    }
}

impl TryFrom<Filter> for segment::types::Filter {
    type Error = Status;

    fn try_from(value: Filter) -> Result<Self, Self::Error> {
        Ok(Self {
            should: conditions_helper_from_grpc(value.should)?,
            min_should: {
                match value.min_should {
                    Some(MinShould {
                        conditions,
                        min_count,
                    }) => Some(segment::types::MinShould {
                        conditions: conditions_helper_from_grpc(conditions)
                            .map(|conds| conds.unwrap_or_default())?,
                        min_count: min_count as usize,
                    }),
                    None => None,
                }
            },
            must: conditions_helper_from_grpc(value.must)?,
            must_not: conditions_helper_from_grpc(value.must_not)?,
        })
    }
}

impl From<segment::types::Filter> for Filter {
    fn from(value: segment::types::Filter) -> Self {
        Self {
            should: conditions_helper_to_grpc(value.should),
            min_should: {
                if let Some(segment::types::MinShould {
                    conditions,
                    min_count,
                }) = value.min_should
                {
                    Some(MinShould {
                        conditions: conditions_helper_to_grpc(Some(conditions)),
                        min_count: min_count as u64,
                    })
                } else {
                    None
                }
            },
            must: conditions_helper_to_grpc(value.must),
            must_not: conditions_helper_to_grpc(value.must_not),
        }
    }
}

impl TryFrom<Condition> for segment::types::Condition {
    type Error = Status;

    fn try_from(value: Condition) -> Result<Self, Self::Error> {
        if let Some(condition) = value.condition_one_of {
            return match condition {
                ConditionOneOf::Field(field) => {
                    Ok(segment::types::Condition::Field(field.try_into()?))
                }
                ConditionOneOf::HasId(has_id) => {
                    Ok(segment::types::Condition::HasId(has_id.try_into()?))
                }
                ConditionOneOf::Filter(filter) => {
                    Ok(segment::types::Condition::Filter(filter.try_into()?))
                }
                ConditionOneOf::IsEmpty(is_empty) => {
                    Ok(segment::types::Condition::IsEmpty(is_empty.try_into()?))
                }
                ConditionOneOf::IsNull(is_null) => {
                    Ok(segment::types::Condition::IsNull(is_null.try_into()?))
                }
                ConditionOneOf::Nested(nested) => Ok(segment::types::Condition::Nested(
                    segment::types::NestedCondition::new(nested.try_into()?),
                )),
                ConditionOneOf::HasVector(has_vector) => Ok(segment::types::Condition::HasVector(
                    segment::types::HasVectorCondition {
                        has_vector: has_vector.has_vector,
                    },
                )),
            };
        }
        Err(Status::invalid_argument("Malformed Condition type"))
    }
}

impl From<segment::types::Condition> for Condition {
    fn from(value: segment::types::Condition) -> Self {
        let condition_one_of = match value {
            segment::types::Condition::Field(field) => {
                Some(ConditionOneOf::Field(FieldCondition::from(field)))
            }
            segment::types::Condition::IsEmpty(is_empty) => {
                Some(ConditionOneOf::IsEmpty(IsEmptyCondition::from(is_empty)))
            }
            segment::types::Condition::IsNull(is_null) => {
                Some(ConditionOneOf::IsNull(IsNullCondition::from(is_null)))
            }
            segment::types::Condition::HasId(has_id) => {
                Some(ConditionOneOf::HasId(HasIdCondition::from(has_id)))
            }
            segment::types::Condition::Filter(filter) => {
                Some(ConditionOneOf::Filter(Filter::from(filter)))
            }
            segment::types::Condition::Nested(nested) => {
                Some(ConditionOneOf::Nested(NestedCondition::from(nested.nested)))
            }
            // This type of condition should be only applied locally
            // and never be sent to the other peers
            segment::types::Condition::CustomIdChecker(_) => None,
            segment::types::Condition::HasVector(has_vector) => {
                Some(ConditionOneOf::HasVector(HasVectorCondition {
                    has_vector: has_vector.has_vector,
                }))
            }
        };

        Self { condition_one_of }
    }
}

impl TryFrom<NestedCondition> for segment::types::Nested {
    type Error = Status;

    fn try_from(value: NestedCondition) -> Result<Self, Self::Error> {
        match value.filter {
            None => Err(Status::invalid_argument(
                "Nested condition must have a filter",
            )),
            Some(filter) => Ok(Self {
                key: json::json_path_from_proto(&value.key)?,
                filter: filter.try_into()?,
            }),
        }
    }
}

impl From<segment::types::Nested> for NestedCondition {
    fn from(value: segment::types::Nested) -> Self {
        Self {
            key: value.key.to_string(),
            filter: Some(value.filter.into()),
        }
    }
}

impl TryFrom<IsEmptyCondition> for segment::types::IsEmptyCondition {
    type Error = Status;

    fn try_from(value: IsEmptyCondition) -> Result<Self, Status> {
        Ok(segment::types::IsEmptyCondition {
            is_empty: segment::types::PayloadField {
                key: json::json_path_from_proto(&value.key)?,
            },
        })
    }
}

impl From<segment::types::IsEmptyCondition> for IsEmptyCondition {
    fn from(value: segment::types::IsEmptyCondition) -> Self {
        Self {
            key: value.is_empty.key.to_string(),
        }
    }
}

impl TryFrom<IsNullCondition> for segment::types::IsNullCondition {
    type Error = Status;

    fn try_from(value: IsNullCondition) -> Result<Self, Status> {
        Ok(segment::types::IsNullCondition {
            is_null: segment::types::PayloadField {
                key: json::json_path_from_proto(&value.key)?,
            },
        })
    }
}

impl From<segment::types::IsNullCondition> for IsNullCondition {
    fn from(value: segment::types::IsNullCondition) -> Self {
        Self {
            key: value.is_null.key.to_string(),
        }
    }
}

impl TryFrom<HasIdCondition> for segment::types::HasIdCondition {
    type Error = Status;

    fn try_from(value: HasIdCondition) -> Result<Self, Self::Error> {
        let set: HashSet<segment::types::PointIdType> = value
            .has_id
            .into_iter()
            .map(|p| p.try_into())
            .collect::<Result<_, _>>()?;
        Ok(Self { has_id: set })
    }
}

impl From<segment::types::HasIdCondition> for HasIdCondition {
    fn from(value: segment::types::HasIdCondition) -> Self {
        let set: Vec<PointId> = value.has_id.into_iter().map(|p| p.into()).collect();
        Self { has_id: set }
    }
}

impl TryFrom<FieldCondition> for segment::types::FieldCondition {
    type Error = Status;

    fn try_from(value: FieldCondition) -> Result<Self, Self::Error> {
        let FieldCondition {
            key,
            r#match,
            range,
            geo_bounding_box,
            geo_radius,
            values_count,
            geo_polygon,
            datetime_range,
        } = value;

        let geo_bounding_box =
            geo_bounding_box.map_or_else(|| Ok(None), |g| g.try_into().map(Some))?;
        let geo_radius = geo_radius.map_or_else(|| Ok(None), |g| g.try_into().map(Some))?;
        let geo_polygon = geo_polygon.map_or_else(|| Ok(None), |g| g.try_into().map(Some))?;

        let mut range = range.map(Into::into);
        if range.is_none() {
            range = datetime_range
                .map(segment::types::RangeInterface::try_from)
                .transpose()?;
        }

        Ok(Self {
            key: json::json_path_from_proto(&key)?,
            r#match: r#match.map_or_else(|| Ok(None), |m| m.try_into().map(Some))?,
            range,
            geo_bounding_box,
            geo_radius,
            geo_polygon,
            values_count: values_count.map(Into::into),
        })
    }
}

impl From<segment::types::FieldCondition> for FieldCondition {
    fn from(value: segment::types::FieldCondition) -> Self {
        let segment::types::FieldCondition {
            key,
            r#match,
            range,
            geo_bounding_box,
            geo_radius,
            geo_polygon,
            values_count,
        } = value;

        let (range, datetime_range) = match range {
            Some(segment::types::RangeInterface::Float(range)) => (Some(range.into()), None),
            Some(segment::types::RangeInterface::DateTime(range)) => (None, Some(range.into())),
            None => (None, None),
        };

        Self {
            key: key.to_string(),
            r#match: r#match.map(Into::into),
            range,
            geo_bounding_box: geo_bounding_box.map(Into::into),
            geo_radius: geo_radius.map(Into::into),
            geo_polygon: geo_polygon.map(Into::into),
            values_count: values_count.map(Into::into),
            datetime_range,
        }
    }
}

impl TryFrom<GeoBoundingBox> for segment::types::GeoBoundingBox {
    type Error = Status;

    fn try_from(value: GeoBoundingBox) -> Result<Self, Self::Error> {
        match value {
            GeoBoundingBox {
                top_left: Some(t),
                bottom_right: Some(b),
            } => Ok(Self {
                top_left: t.into(),
                bottom_right: b.into(),
            }),
            _ => Err(Status::invalid_argument("Malformed GeoBoundingBox type")),
        }
    }
}

impl From<segment::types::GeoBoundingBox> for GeoBoundingBox {
    fn from(value: segment::types::GeoBoundingBox) -> Self {
        Self {
            top_left: Some(value.top_left.into()),
            bottom_right: Some(value.bottom_right.into()),
        }
    }
}

impl TryFrom<GeoRadius> for segment::types::GeoRadius {
    type Error = Status;

    fn try_from(value: GeoRadius) -> Result<Self, Self::Error> {
        match value {
            GeoRadius {
                center: Some(c),
                radius,
            } => Ok(Self {
                center: c.into(),
                radius: radius.into(),
            }),
            _ => Err(Status::invalid_argument("Malformed GeoRadius type")),
        }
    }
}

impl From<segment::types::GeoRadius> for GeoRadius {
    fn from(value: segment::types::GeoRadius) -> Self {
        Self {
            center: Some(value.center.into()),
            radius: value.radius as f32, // TODO lossy ok?
        }
    }
}

impl TryFrom<GeoPolygon> for segment::types::GeoPolygon {
    type Error = Status;

    fn try_from(value: GeoPolygon) -> Result<Self, Self::Error> {
        match value {
            GeoPolygon {
                exterior: Some(e),
                interiors,
            } => Ok(Self {
                exterior: e.into(),
                interiors: Some(interiors.into_iter().map(Into::into).collect()),
            }),
            _ => Err(Status::invalid_argument(
                "Malformed GeoPolygon type - field `exterior` is required",
            )),
        }
    }
}

impl From<segment::types::GeoPolygon> for GeoPolygon {
    fn from(value: segment::types::GeoPolygon) -> Self {
        Self {
            exterior: Some(value.exterior.into()),
            interiors: value
                .interiors
                .unwrap_or_default()
                .into_iter()
                .map(Into::into)
                .collect(),
        }
    }
}

impl From<GeoPoint> for segment::types::GeoPoint {
    fn from(value: GeoPoint) -> Self {
        Self {
            lon: value.lon,
            lat: value.lat,
        }
    }
}

impl From<GeoLineString> for segment::types::GeoLineString {
    fn from(value: GeoLineString) -> Self {
        Self {
            points: value.points.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<segment::types::GeoLineString> for GeoLineString {
    fn from(value: segment::types::GeoLineString) -> Self {
        Self {
            points: value.points.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<Range> for segment::types::Range<FloatPayloadType> {
    fn from(value: Range) -> Self {
        Self {
            lt: value.lt,
            gt: value.gt,
            gte: value.gte,
            lte: value.lte,
        }
    }
}

impl From<segment::types::Range<FloatPayloadType>> for Range {
    fn from(value: segment::types::Range<FloatPayloadType>) -> Self {
        Self {
            lt: value.lt,
            gt: value.gt,
            gte: value.gte,
            lte: value.lte,
        }
    }
}

impl From<Range> for segment::types::RangeInterface {
    fn from(value: Range) -> Self {
        Self::Float(value.into())
    }
}

impl TryFrom<DatetimeRange> for segment::types::RangeInterface {
    type Error = Status;

    fn try_from(value: DatetimeRange) -> Result<Self, Self::Error> {
        Ok(Self::DateTime(segment::types::Range {
            lt: value.lt.map(try_date_time_from_proto).transpose()?,
            gt: value.gt.map(try_date_time_from_proto).transpose()?,
            gte: value.gte.map(try_date_time_from_proto).transpose()?,
            lte: value.lte.map(try_date_time_from_proto).transpose()?,
        }))
    }
}

impl From<segment::types::Range<DateTimePayloadType>> for DatetimeRange {
    fn from(value: segment::types::Range<DateTimePayloadType>) -> Self {
        Self {
            lt: value.lt.map(date_time_to_proto),
            gt: value.gt.map(date_time_to_proto),
            gte: value.gte.map(date_time_to_proto),
            lte: value.lte.map(date_time_to_proto),
        }
    }
}

impl From<ValuesCount> for segment::types::ValuesCount {
    fn from(value: ValuesCount) -> Self {
        Self {
            lt: value.lt.map(|x| x as usize),
            gt: value.gt.map(|x| x as usize),
            gte: value.gte.map(|x| x as usize),
            lte: value.lte.map(|x| x as usize),
        }
    }
}

impl From<segment::types::ValuesCount> for ValuesCount {
    fn from(value: segment::types::ValuesCount) -> Self {
        Self {
            lt: value.lt.map(|x| x as u64),
            gt: value.gt.map(|x| x as u64),
            gte: value.gte.map(|x| x as u64),
            lte: value.lte.map(|x| x as u64),
        }
    }
}

impl TryFrom<Match> for segment::types::Match {
    type Error = Status;

    fn try_from(value: Match) -> Result<Self, Self::Error> {
        match value.match_value {
            Some(mv) => Ok(match mv {
                MatchValue::Keyword(kw) => kw.into(),
                MatchValue::Integer(int) => int.into(),
                MatchValue::Boolean(flag) => flag.into(),
                MatchValue::Text(text) => segment::types::Match::Text(text.into()),
                MatchValue::Keywords(kwds) => kwds.strings.into(),
                MatchValue::Integers(ints) => ints.integers.into(),
                MatchValue::ExceptIntegers(kwds) => {
                    segment::types::Match::Except(kwds.integers.into())
                }
                MatchValue::ExceptKeywords(ints) => {
                    segment::types::Match::Except(ints.strings.into())
                }
            }),
            _ => Err(Status::invalid_argument("Malformed Match condition")),
        }
    }
}

impl From<segment::types::Match> for Match {
    fn from(value: segment::types::Match) -> Self {
        let match_value = match value {
            segment::types::Match::Value(value) => match value.value {
                segment::types::ValueVariants::String(kw) => MatchValue::Keyword(kw),
                segment::types::ValueVariants::Integer(int) => MatchValue::Integer(int),
                segment::types::ValueVariants::Bool(flag) => MatchValue::Boolean(flag),
            },
            segment::types::Match::Text(segment::types::MatchText { text }) => {
                MatchValue::Text(text)
            }
            segment::types::Match::Any(any) => match any.any {
                segment::types::AnyVariants::Strings(strings) => {
                    let strings = strings.into_iter().collect();
                    MatchValue::Keywords(RepeatedStrings { strings })
                }
                segment::types::AnyVariants::Integers(integers) => {
                    let integers = integers.into_iter().collect();
                    MatchValue::Integers(RepeatedIntegers { integers })
                }
            },
            segment::types::Match::Except(except) => match except.except {
                segment::types::AnyVariants::Strings(strings) => {
                    let strings = strings.into_iter().collect();
                    MatchValue::ExceptKeywords(RepeatedStrings { strings })
                }
                segment::types::AnyVariants::Integers(integers) => {
                    let integers = integers.into_iter().collect();
                    MatchValue::ExceptIntegers(RepeatedIntegers { integers })
                }
            },
        };
        Self {
            match_value: Some(match_value),
        }
    }
}

impl From<Direction> for segment::data_types::order_by::Direction {
    fn from(value: Direction) -> Self {
        match value {
            Direction::Asc => segment::data_types::order_by::Direction::Asc,
            Direction::Desc => segment::data_types::order_by::Direction::Desc,
        }
    }
}

impl From<segment::data_types::order_by::Direction> for Direction {
    fn from(value: segment::data_types::order_by::Direction) -> Self {
        match value {
            segment::data_types::order_by::Direction::Asc => Direction::Asc,
            segment::data_types::order_by::Direction::Desc => Direction::Desc,
        }
    }
}
impl TryFrom<OrderBy> for segment::data_types::order_by::OrderBy {
    type Error = Status;

    fn try_from(value: OrderBy) -> Result<Self, Self::Error> {
        use segment::data_types::order_by::StartFrom;

        use crate::conversions::json;
        use crate::grpc::qdrant::start_from::Value;

        let direction = value
            .direction
            .and_then(|x|
                // XXX: Invalid values silently converted to None
                Direction::try_from(x).ok())
            .map(segment::data_types::order_by::Direction::from);

        let start_from = value
            .start_from
            .and_then(|value| value.value)
            .map(|v| -> Result<StartFrom, Status> {
                match v {
                    Value::Integer(int) => Ok(StartFrom::Integer(int)),
                    Value::Float(float) => Ok(StartFrom::Float(float)),
                    Value::Timestamp(timestamp) => {
                        Ok(StartFrom::Datetime(try_date_time_from_proto(timestamp)?))
                    }
                    Value::Datetime(datetime_str) => Ok(StartFrom::Datetime(
                        segment::types::DateTimeWrapper::from_str(&datetime_str).map_err(|e| {
                            Status::invalid_argument(format!("Malformed datetime: {e}"))
                        })?,
                    )),
                }
            })
            .transpose()?;

        Ok(Self {
            key: json::json_path_from_proto(&value.key)?,
            direction,
            start_from,
        })
    }
}

impl From<segment::data_types::order_by::OrderBy> for OrderBy {
    fn from(value: segment::data_types::order_by::OrderBy) -> Self {
        Self {
            key: value.key.to_string(),
            direction: value.direction.map(|d| Direction::from(d) as i32),
            start_from: value.start_from.map(|start_from| start_from.into()),
        }
    }
}

impl From<segment::data_types::order_by::StartFrom> for StartFrom {
    fn from(value: segment::data_types::order_by::StartFrom) -> Self {
        Self {
            value: Some(match value {
                segment::data_types::order_by::StartFrom::Integer(int) => {
                    start_from::Value::Integer(int)
                }
                segment::data_types::order_by::StartFrom::Float(float) => {
                    start_from::Value::Float(float)
                }
                segment::data_types::order_by::StartFrom::Datetime(datetime) => {
                    start_from::Value::Timestamp(date_time_to_proto(datetime))
                }
            }),
        }
    }
}

impl From<HnswConfigDiff> for segment::types::HnswConfig {
    fn from(hnsw_config: HnswConfigDiff) -> Self {
        Self {
            m: hnsw_config.m.unwrap_or_default() as usize,
            ef_construct: hnsw_config.ef_construct.unwrap_or_default() as usize,
            full_scan_threshold: hnsw_config.full_scan_threshold.unwrap_or_default() as usize,
            max_indexing_threads: hnsw_config.max_indexing_threads.unwrap_or_default() as usize,
            on_disk: hnsw_config.on_disk,
            payload_m: hnsw_config.payload_m.map(|x| x as usize),
        }
    }
}

impl From<StrictModeConfig> for segment::types::StrictModeConfig {
    fn from(value: StrictModeConfig) -> Self {
        Self {
            enabled: value.enabled,
            max_query_limit: value.max_query_limit.map(|i| i as usize),
            max_timeout: value.max_timeout.map(|i| i as usize),
            unindexed_filtering_retrieve: value.unindexed_filtering_retrieve,
            unindexed_filtering_update: value.unindexed_filtering_update,
            search_max_hnsw_ef: value.search_max_hnsw_ef.map(|i| i as usize),
            search_allow_exact: value.search_allow_exact,
            search_max_oversampling: value.search_max_oversampling.map(f64::from),
        }
    }
}

impl From<segment::types::StrictModeConfig> for StrictModeConfig {
    fn from(value: segment::types::StrictModeConfig) -> Self {
        Self {
            enabled: value.enabled,
            max_query_limit: value.max_query_limit.map(|i| i as u32),
            max_timeout: value.max_timeout.map(|i| i as u32),
            unindexed_filtering_retrieve: value.unindexed_filtering_retrieve,
            unindexed_filtering_update: value.unindexed_filtering_update,
            search_max_hnsw_ef: value.search_max_hnsw_ef.map(|i| i as u32),
            search_allow_exact: value.search_allow_exact,
            search_max_oversampling: value.search_max_oversampling.map(|i| i as f32),
        }
    }
}

pub fn naive_date_time_to_proto(date_time: NaiveDateTime) -> prost_wkt_types::Timestamp {
    prost_wkt_types::Timestamp {
        seconds: date_time.and_utc().timestamp(), // number of non-leap seconds since the midnight on January 1, 1970.
        nanos: date_time.nanosecond() as i32,
    }
}

pub fn date_time_to_proto(date_time: DateTimePayloadType) -> prost_wkt_types::Timestamp {
    naive_date_time_to_proto(date_time.0.naive_utc())
}

pub fn try_date_time_from_proto(
    date_time: prost_wkt_types::Timestamp,
) -> Result<DateTimePayloadType, Status> {
    chrono::DateTime::from_timestamp(date_time.seconds, date_time.nanos.try_into().unwrap_or(0))
        .map(|date_time| date_time.into())
        .ok_or_else(|| Status::invalid_argument(format!("Unable to parse timestamp: {date_time}")))
}

impl TryFrom<Distance> for segment::types::Distance {
    type Error = Status;

    fn try_from(value: Distance) -> Result<Self, Self::Error> {
        Ok(match value {
            Distance::UnknownDistance => {
                return Err(Status::invalid_argument(
                    "Malformed distance parameter: UnknownDistance",
                ));
            }
            Distance::Cosine => segment::types::Distance::Cosine,
            Distance::Euclid => segment::types::Distance::Euclid,
            Distance::Dot => segment::types::Distance::Dot,
            Distance::Manhattan => segment::types::Distance::Manhattan,
        })
    }
}

pub fn from_grpc_dist(dist: i32) -> Result<segment::types::Distance, Status> {
    match Distance::try_from(dist) {
        Err(_) => Err(Status::invalid_argument(format!(
            "Malformed distance parameter, unexpected value: {dist}"
        ))),
        Ok(grpc_distance) => Ok(grpc_distance.try_into()?),
    }
}

pub fn into_named_vector_struct(
    vector_name: Option<String>,
    vector: segment_vectors::DenseVector,
    indices: Option<SparseIndices>,
) -> Result<segment_vectors::NamedVectorStruct, Status> {
    use segment_vectors::{NamedSparseVector, NamedVector, NamedVectorStruct};
    use sparse::common::sparse_vector::SparseVector;
    Ok(match indices {
        Some(indices) => NamedVectorStruct::Sparse(NamedSparseVector {
            name: vector_name
                .ok_or_else(|| Status::invalid_argument("Sparse vector must have a name"))?,
            vector: SparseVector::new(indices.data, vector).map_err(|_| {
                Status::invalid_argument("Sparse indices does not match sparse vector conditions")
            })?,
        }),
        None => {
            if let Some(vector_name) = vector_name {
                NamedVectorStruct::Dense(NamedVector {
                    name: vector_name,
                    vector,
                })
            } else {
                NamedVectorStruct::Default(vector)
            }
        }
    })
}

impl From<PointsOperationResponseInternal> for PointsOperationResponse {
    fn from(resp: PointsOperationResponseInternal) -> Self {
        Self {
            result: resp.result.map(Into::into),
            time: resp.time,
        }
    }
}

// TODO: Make it explicit `from_operations_response` method instead of `impl From<PointsOperationResponse>`?
impl From<PointsOperationResponse> for PointsOperationResponseInternal {
    fn from(resp: PointsOperationResponse) -> Self {
        Self {
            result: resp.result.map(Into::into),
            time: resp.time,
        }
    }
}

impl From<UpdateResultInternal> for UpdateResult {
    fn from(res: UpdateResultInternal) -> Self {
        Self {
            operation_id: res.operation_id,
            status: res.status,
        }
    }
}

// TODO: Make it explicit `from_update_result` method instead of `impl From<UpdateResult>`?
impl From<UpdateResult> for UpdateResultInternal {
    fn from(res: UpdateResult) -> Self {
        Self {
            operation_id: res.operation_id,
            status: res.status,
            clock_tag: None,
        }
    }
}

impl From<RecommendStrategy> for crate::rest::RecommendStrategy {
    fn from(value: RecommendStrategy) -> Self {
        match value {
            RecommendStrategy::AverageVector => crate::rest::RecommendStrategy::AverageVector,
            RecommendStrategy::BestScore => crate::rest::RecommendStrategy::BestScore,
        }
    }
}

impl TryFrom<i32> for crate::rest::RecommendStrategy {
    type Error = Status;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        let strategy = RecommendStrategy::try_from(value).map_err(|_| {
            Status::invalid_argument(format!("Unknown recommend strategy: {value}"))
        })?;
        Ok(strategy.into())
    }
}

impl From<segment_query::RecoQuery<segment_vectors::VectorInternal>> for raw_query::Recommend {
    fn from(value: segment_query::RecoQuery<segment_vectors::VectorInternal>) -> Self {
        Self {
            positives: value.positives.into_iter().map(RawVector::from).collect(),
            negatives: value.negatives.into_iter().map(RawVector::from).collect(),
        }
    }
}

impl TryFrom<raw_query::Recommend> for segment_query::RecoQuery<segment_vectors::VectorInternal> {
    type Error = Status;
    fn try_from(value: raw_query::Recommend) -> Result<Self, Self::Error> {
        Ok(Self {
            positives: value
                .positives
                .into_iter()
                .map(segment_vectors::VectorInternal::try_from)
                .try_collect()?,
            negatives: value
                .negatives
                .into_iter()
                .map(segment_vectors::VectorInternal::try_from)
                .try_collect()?,
        })
    }
}

impl From<segment_query::ContextPair<segment_vectors::VectorInternal>>
    for raw_query::RawContextPair
{
    fn from(value: segment_query::ContextPair<segment_vectors::VectorInternal>) -> Self {
        Self {
            positive: Some(RawVector::from(value.positive)),
            negative: Some(RawVector::from(value.negative)),
        }
    }
}

impl TryFrom<raw_query::RawContextPair>
    for segment_query::ContextPair<segment_vectors::VectorInternal>
{
    type Error = Status;
    fn try_from(value: raw_query::RawContextPair) -> Result<Self, Self::Error> {
        Ok(Self {
            positive: value
                .positive
                .map(segment_vectors::VectorInternal::try_from)
                .transpose()?
                .ok_or_else(|| {
                    Status::invalid_argument("No positive part of context pair provided")
                })?,
            negative: value
                .negative
                .map(segment_vectors::VectorInternal::try_from)
                .transpose()?
                .ok_or_else(|| {
                    Status::invalid_argument("No negative part of context pair provided")
                })?,
        })
    }
}

impl From<segment_query::ContextQuery<segment_vectors::VectorInternal>> for raw_query::Context {
    fn from(value: segment_query::ContextQuery<segment_vectors::VectorInternal>) -> Self {
        Self {
            context: value.pairs.into_iter().map(RawContextPair::from).collect(),
        }
    }
}

impl TryFrom<raw_query::Context> for segment_query::ContextQuery<segment_vectors::VectorInternal> {
    type Error = Status;
    fn try_from(value: raw_query::Context) -> Result<Self, Self::Error> {
        Ok(Self {
            pairs: value
                .context
                .into_iter()
                .map(segment_query::ContextPair::try_from)
                .try_collect()?,
        })
    }
}

impl From<segment_query::DiscoveryQuery<segment_vectors::VectorInternal>> for raw_query::Discovery {
    fn from(value: segment_query::DiscoveryQuery<segment_vectors::VectorInternal>) -> Self {
        Self {
            target: Some(RawVector::from(value.target)),
            context: value.pairs.into_iter().map(RawContextPair::from).collect(),
        }
    }
}

impl TryFrom<raw_query::Discovery>
    for segment_query::DiscoveryQuery<segment_vectors::VectorInternal>
{
    type Error = Status;
    fn try_from(value: raw_query::Discovery) -> Result<Self, Self::Error> {
        Ok(Self {
            target: value
                .target
                .map(segment_vectors::VectorInternal::try_from)
                .transpose()?
                .ok_or_else(|| Status::invalid_argument("No target provided"))?,
            pairs: value
                .context
                .into_iter()
                .map(segment_query::ContextPair::try_from)
                .try_collect()?,
        })
    }
}

impl TryFrom<SearchPoints> for rest::SearchRequestInternal {
    type Error = Status;

    fn try_from(value: SearchPoints) -> Result<Self, Self::Error> {
        let named_struct = crate::grpc::conversions::into_named_vector_struct(
            value.vector_name,
            value.vector,
            value.sparse_indices,
        )?;
        let vector = match named_struct {
            segment_vectors::NamedVectorStruct::Default(v) => rest::NamedVectorStruct::Default(v),
            segment_vectors::NamedVectorStruct::Dense(v) => rest::NamedVectorStruct::Dense(v),
            segment_vectors::NamedVectorStruct::Sparse(v) => rest::NamedVectorStruct::Sparse(v),
            segment_vectors::NamedVectorStruct::MultiDense(_) => {
                return Err(Status::invalid_argument(
                    "MultiDense vector is not supported in search request",
                ))
            }
        };
        Ok(Self {
            vector,
            filter: value.filter.map(|f| f.try_into()).transpose()?,
            params: value.params.map(|p| p.into()),
            limit: value.limit as usize,
            offset: value.offset.map(|x| x as usize),
            with_payload: value.with_payload.map(|wp| wp.try_into()).transpose()?,
            with_vector: Some(
                value
                    .with_vectors
                    .map(|with_vectors| with_vectors.into())
                    .unwrap_or_default(),
            ),
            score_threshold: value.score_threshold,
        })
    }
}

impl TryFrom<SearchPointGroups> for rest::SearchGroupsRequestInternal {
    type Error = Status;

    fn try_from(value: SearchPointGroups) -> Result<Self, Self::Error> {
        let search_points = SearchPoints {
            vector: value.vector,
            filter: value.filter,
            params: value.params,
            with_payload: value.with_payload,
            with_vectors: value.with_vectors,
            score_threshold: value.score_threshold,
            vector_name: value.vector_name,
            limit: 0,
            offset: None,
            collection_name: String::new(),
            read_consistency: None,
            timeout: None,
            shard_key_selector: None,
            sparse_indices: value.sparse_indices,
        };

        if let Some(sparse_indices) = &search_points.sparse_indices {
            validate_sparse_vector_impl(&sparse_indices.data, &search_points.vector).map_err(
                |_| {
                    Status::invalid_argument(
                        "Sparse indices does not match sparse vector conditions",
                    )
                },
            )?;
        }

        let rest::SearchRequestInternal {
            vector,
            filter,
            params,
            limit: _,
            offset: _,
            with_payload,
            with_vector,
            score_threshold,
        } = search_points.try_into()?;

        Ok(Self {
            vector,
            filter,
            params,
            with_payload,
            with_vector,
            score_threshold,
            group_request: rest::BaseGroupRequest {
                group_by: json::json_path_from_proto(&value.group_by)?,
                limit: value.limit,
                group_size: value.group_size,
                with_lookup: value
                    .with_lookup
                    .map(rest::WithLookupInterface::try_from)
                    .transpose()?,
            },
        })
    }
}

impl TryFrom<WithLookup> for rest::WithLookupInterface {
    type Error = Status;

    fn try_from(value: WithLookup) -> Result<Self, Self::Error> {
        Ok(Self::WithLookup(value.try_into()?))
    }
}

impl TryFrom<WithLookup> for rest::WithLookup {
    type Error = Status;

    fn try_from(value: WithLookup) -> Result<Self, Self::Error> {
        let with_default_payload = || Some(segment::types::WithPayloadInterface::Bool(true));

        Ok(Self {
            collection_name: value.collection,
            with_payload: value
                .with_payload
                .map(|wp| wp.try_into())
                .transpose()?
                .or_else(with_default_payload),
            with_vectors: value.with_vectors.map(|wv| wv.into()),
        })
    }
}

impl From<LookupLocation> for rest::LookupLocation {
    fn from(value: LookupLocation) -> Self {
        Self {
            collection: value.collection_name,
            vector: value.vector_name,
            shard_key: value.shard_key_selector.map(rest::ShardKeySelector::from),
        }
    }
}

impl TryFrom<FacetHitInternal> for segment_facets::FacetValueHit {
    type Error = Status;

    fn try_from(hit: FacetHitInternal) -> Result<Self, Self::Error> {
        let value = hit
            .value
            .ok_or_else(|| Status::internal("expected FacetHit to have a value"))?;

        Ok(Self {
            value: segment_facets::FacetValue::try_from(value)?,
            count: hit.count as usize,
        })
    }
}

impl From<segment_facets::FacetValueHit> for FacetHitInternal {
    fn from(hit: segment_facets::FacetValueHit) -> Self {
        Self {
            value: Some(From::from(hit.value)),
            count: hit.count as u64,
        }
    }
}

impl From<segment_facets::FacetValueHit> for FacetHit {
    fn from(hit: segment_facets::FacetValueHit) -> Self {
        Self {
            value: Some(hit.value.into()),
            count: hit.count as u64,
        }
    }
}

impl TryFrom<FacetValueInternal> for segment_facets::FacetValue {
    type Error = Status;

    fn try_from(value: FacetValueInternal) -> Result<Self, Self::Error> {
        use super::qdrant::facet_value_internal::Variant;

        let variant = value
            .variant
            .ok_or_else(|| Status::internal("expected FacetValueInternal to have a value"))?;

        Ok(match variant {
            Variant::KeywordValue(value) => segment_facets::FacetValue::Keyword(value),
            Variant::IntegerValue(value) => segment_facets::FacetValue::Int(value),
            Variant::UuidValue(value) => {
                let uuid_bytes: [u8; 16] = value.try_into().map_err(|_| {
                    Status::invalid_argument("Unable to parse UUID: expected 16 bytes")
                })?;
                segment_facets::FacetValue::Uuid(Uuid::from_bytes(uuid_bytes).as_u128())
            }
            Variant::BoolValue(value) => segment_facets::FacetValue::Bool(value),
        })
    }
}

impl From<segment_facets::FacetValue> for FacetValueInternal {
    fn from(value: segment_facets::FacetValue) -> Self {
        use super::qdrant::facet_value_internal::Variant;

        Self {
            variant: Some(match value {
                segment_facets::FacetValue::Keyword(value) => Variant::KeywordValue(value),
                segment_facets::FacetValue::Int(value) => Variant::IntegerValue(value),
                segment_facets::FacetValue::Uuid(value) => {
                    let uuid = Uuid::from_u128(value);
                    Variant::UuidValue(uuid.as_bytes().to_vec())
                }
                segment_facets::FacetValue::Bool(value) => Variant::BoolValue(value),
            }),
        }
    }
}

impl From<segment_facets::FacetValue> for FacetValue {
    fn from(value: segment_facets::FacetValue) -> Self {
        use super::qdrant::facet_value::Variant;

        Self {
            variant: Some(match value {
                segment_facets::FacetValue::Keyword(value) => Variant::StringValue(value),
                segment_facets::FacetValue::Int(value) => Variant::IntegerValue(value),
                segment_facets::FacetValue::Uuid(value) => {
                    Variant::StringValue(Uuid::from_u128(value).to_string())
                }
                segment_facets::FacetValue::Bool(value) => Variant::BoolValue(value),
            }),
        }
    }
}

impl From<rest::SearchMatrixPair> for SearchMatrixPair {
    fn from(pair: rest::SearchMatrixPair) -> Self {
        Self {
            a: Some(pair.a.into()),
            b: Some(pair.b.into()),
            score: pair.score,
        }
    }
}

impl From<HwMeasurementAcc> for HardwareUsage {
    fn from(value: HwMeasurementAcc) -> Self {
        Self {
            cpu: value.get_cpu() as u64,
        }
    }
}

impl From<HardwareUsage> for HardwareCounterCell {
    fn from(value: HardwareUsage) -> Self {
        let HardwareUsage { cpu } = value;
        HardwareCounterCell::new_with(cpu as usize)
    }
}