gproxy-transform 2.4.4

use crate::protocol::{claude, gemini, openai};

pub(in crate::transform::count_tokens) fn claude_service_tier_to_gemini(
    service_tier: Option<claude::RequestServiceTier>,
) -> Option<gemini::ServiceTier> {
    let tier = match service_tier? {
        claude::RequestServiceTier::Known(claude::RequestServiceTierKnown::Auto) => {
            gemini::ServiceTierKnown::Unspecified
        }
        claude::RequestServiceTier::Known(claude::RequestServiceTierKnown::StandardOnly) => {
            gemini::ServiceTierKnown::Standard
        }
        claude::RequestServiceTier::Unknown(_) => gemini::ServiceTierKnown::Standard,
        _ => {
            unreachable!("new non-exhaustive protocol variant requires a lockstep transform update")
        }
    };
    Some(gemini::ServiceTier::Known(tier))
}

pub(in crate::transform::count_tokens) fn openai_service_tier_to_gemini(
    service_tier: Option<openai::ServiceTier>,
) -> Option<gemini::ServiceTier> {
    let tier = match service_tier? {
        openai::ServiceTier::Auto => gemini::ServiceTierKnown::Unspecified,
        openai::ServiceTier::Default | openai::ServiceTier::OnDemand => {
            gemini::ServiceTierKnown::Standard
        }
        openai::ServiceTier::Flex => gemini::ServiceTierKnown::Flex,
        openai::ServiceTier::Fast | openai::ServiceTier::Priority => {
            gemini::ServiceTierKnown::Priority
        }
        openai::ServiceTier::Scale => gemini::ServiceTierKnown::Standard,
        _ => {
            unreachable!("new non-exhaustive protocol variant requires a lockstep transform update")
        }
    };
    Some(gemini::ServiceTier::Known(tier))
}

pub(in crate::transform::count_tokens) fn gemini_service_tier_to_claude(
    service_tier: Option<gemini::ServiceTier>,
) -> Option<claude::RequestServiceTier> {
    let service_tier = match service_tier? {
        gemini::ServiceTier::Known(gemini::ServiceTierKnown::Standard) => {
            claude::RequestServiceTierKnown::StandardOnly
        }
        gemini::ServiceTier::Known(gemini::ServiceTierKnown::Flex)
        | gemini::ServiceTier::Known(gemini::ServiceTierKnown::Priority)
        | gemini::ServiceTier::Known(gemini::ServiceTierKnown::Unspecified) => {
            claude::RequestServiceTierKnown::Auto
        }
        gemini::ServiceTier::Unknown(_) => claude::RequestServiceTierKnown::StandardOnly,
        _ => {
            unreachable!("new non-exhaustive protocol variant requires a lockstep transform update")
        }
    };
    Some(claude::RequestServiceTier::Known(service_tier))
}

pub(in crate::transform::count_tokens) fn openai_service_tier_to_claude(
    service_tier: Option<openai::ServiceTier>,
) -> Option<claude::RequestServiceTier> {
    let service_tier = match service_tier? {
        openai::ServiceTier::Auto => claude::RequestServiceTierKnown::Auto,
        openai::ServiceTier::Default | openai::ServiceTier::OnDemand => {
            claude::RequestServiceTierKnown::StandardOnly
        }
        openai::ServiceTier::Fast
        | openai::ServiceTier::Flex
        | openai::ServiceTier::Scale
        | openai::ServiceTier::Priority => claude::RequestServiceTierKnown::Auto,
        _ => {
            unreachable!("new non-exhaustive protocol variant requires a lockstep transform update")
        }
    };
    Some(claude::RequestServiceTier::Known(service_tier))
}

pub(in crate::transform::count_tokens) fn gemini_service_tier_to_openai(
    service_tier: Option<gemini::ServiceTier>,
) -> Option<openai::ServiceTier> {
    let service_tier = match service_tier? {
        gemini::ServiceTier::Known(gemini::ServiceTierKnown::Flex) => openai::ServiceTier::Flex,
        gemini::ServiceTier::Known(gemini::ServiceTierKnown::Priority) => {
            openai::ServiceTier::Priority
        }
        gemini::ServiceTier::Known(gemini::ServiceTierKnown::Standard)
        | gemini::ServiceTier::Known(gemini::ServiceTierKnown::Unspecified)
        | gemini::ServiceTier::Unknown(_) => openai::ServiceTier::Default,
        _ => {
            unreachable!("new non-exhaustive protocol variant requires a lockstep transform update")
        }
    };
    Some(service_tier)
}

pub(in crate::transform::count_tokens) fn claude_service_tier_to_openai(
    service_tier: Option<claude::RequestServiceTier>,
) -> Option<openai::ServiceTier> {
    let service_tier = match service_tier? {
        claude::RequestServiceTier::Known(claude::RequestServiceTierKnown::Auto) => {
            openai::ServiceTier::Auto
        }
        claude::RequestServiceTier::Known(claude::RequestServiceTierKnown::StandardOnly)
        | claude::RequestServiceTier::Unknown(_) => openai::ServiceTier::Default,
        _ => {
            unreachable!("new non-exhaustive protocol variant requires a lockstep transform update")
        }
    };
    Some(service_tier)
}

pub(in crate::transform::count_tokens) fn openai_service_tier_to_claude_speed(
    service_tier: Option<openai::ServiceTier>,
) -> Option<claude::Speed> {
    match service_tier {
        Some(openai::ServiceTier::Fast | openai::ServiceTier::Priority) => {
            Some(claude::Speed::Known(claude::SpeedKnown::Fast))
        }
        _ => None,
    }
}

pub(in crate::transform::count_tokens) fn claude_speed_to_openai(
    speed: Option<claude::Speed>,
) -> Option<openai::ServiceTier> {
    match speed {
        Some(claude::Speed::Known(claude::SpeedKnown::Fast)) => Some(openai::ServiceTier::Priority),
        _ => None,
    }
}

pub(in crate::transform::count_tokens) fn claude_speed_to_gemini(
    speed: Option<claude::Speed>,
) -> Option<gemini::ServiceTier> {
    match speed {
        Some(claude::Speed::Known(claude::SpeedKnown::Fast)) => Some(gemini::ServiceTier::Known(
            gemini::ServiceTierKnown::Priority,
        )),
        _ => None,
    }
}

pub(in crate::transform::count_tokens) fn gemini_service_tier_to_claude_speed(
    service_tier: Option<gemini::ServiceTier>,
) -> Option<claude::Speed> {
    match service_tier {
        Some(gemini::ServiceTier::Known(gemini::ServiceTierKnown::Priority)) => {
            Some(claude::Speed::Known(claude::SpeedKnown::Fast))
        }
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn preserves_fast_semantics_for_count_tokens() {
        assert_eq!(
            openai_service_tier_to_claude_speed(Some(openai::ServiceTier::Fast)),
            Some(claude::Speed::Known(claude::SpeedKnown::Fast))
        );
        assert_eq!(
            claude_speed_to_openai(Some(claude::Speed::Known(claude::SpeedKnown::Fast))),
            Some(openai::ServiceTier::Priority)
        );
        assert_eq!(
            claude_speed_to_gemini(Some(claude::Speed::Known(claude::SpeedKnown::Fast))),
            Some(gemini::ServiceTier::Known(
                gemini::ServiceTierKnown::Priority
            ))
        );
        assert_eq!(
            gemini_service_tier_to_claude_speed(Some(gemini::ServiceTier::Known(
                gemini::ServiceTierKnown::Priority,
            ))),
            Some(claude::Speed::Known(claude::SpeedKnown::Fast))
        );
    }
}