// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {fidl_fuchsia_wlan_policy as fidl_policy, serde::Serialize};

/// Structs for wlan policy to go through SL4F
#[derive(Serialize)]
pub enum WlanClientState {
    ConnectionsDisabled,
    ConnectionsEnabled,
}

impl From<fidl_policy::WlanClientState> for WlanClientState {
    fn from(state: fidl_policy::WlanClientState) -> Self {
        match state {
            fidl_policy::WlanClientState::ConnectionsDisabled => Self::ConnectionsDisabled,
            fidl_policy::WlanClientState::ConnectionsEnabled => Self::ConnectionsEnabled,
        }
    }
}

#[derive(Serialize)]
pub enum ConnectionState {
    Failed,
    Disconnected,
    Connecting,
    Connected,
}

impl From<fidl_policy::ConnectionState> for ConnectionState {
    fn from(state: fidl_policy::ConnectionState) -> Self {
        match state {
            fidl_policy::ConnectionState::Failed => Self::Failed,
            fidl_policy::ConnectionState::Disconnected => Self::Disconnected,
            fidl_policy::ConnectionState::Connecting => Self::Connecting,
            fidl_policy::ConnectionState::Connected => Self::Connected,
        }
    }
}

#[derive(Serialize)]
pub enum SecurityType {
    None = 1,
    Wep = 2,
    Wpa = 3,
    Wpa2 = 4,
    Wpa3 = 5,
}

#[derive(Serialize)]
pub enum DisconnectStatus {
    TimedOut = 1,
    CredentialsFailed = 2,
    ConnectionStopped = 3,
    ConnectionFailed = 4,
}

impl From<fidl_policy::DisconnectStatus> for DisconnectStatus {
    fn from(status: fidl_policy::DisconnectStatus) -> Self {
        match status {
            fidl_policy::DisconnectStatus::TimedOut => Self::TimedOut,
            fidl_policy::DisconnectStatus::CredentialsFailed => Self::CredentialsFailed,
            fidl_policy::DisconnectStatus::ConnectionStopped => Self::ConnectionStopped,
            fidl_policy::DisconnectStatus::ConnectionFailed => Self::ConnectionFailed,
        }
    }
}

#[derive(Serialize)]
pub struct NetworkIdentifier {
    /// Network name, often used by users to choose between networks in the UI.
    pub ssid: String,
    /// Protection type (or not) for the network.
    pub type_: SecurityType,
}

#[derive(Serialize)]
pub struct NetworkState {
    /// Network id for the current connection (or attempt).
    pub id: Option<NetworkIdentifier>,
    /// Current state for the connection.
    pub state: Option<ConnectionState>,
    /// Extra information for debugging or Settings display
    pub status: Option<DisconnectStatus>,
}

impl From<fidl_policy::NetworkState> for NetworkState {
    fn from(state: fidl_policy::NetworkState) -> Self {
        NetworkState {
            id: state.id.map(NetworkIdentifier::from),
            state: state.state.map(ConnectionState::from),
            status: state.status.map(DisconnectStatus::from),
        }
    }
}

#[derive(Serialize)]
pub struct ClientStateSummary {
    /// State indicating whether wlan will attempt to connect to networks or not.
    pub state: Option<WlanClientState>,

    /// Active connections, connection attempts or failed connections.
    pub networks: Option<Vec<NetworkState>>,
}

impl From<fidl_policy::ClientStateSummary> for ClientStateSummary {
    fn from(summary: fidl_policy::ClientStateSummary) -> ClientStateSummary {
        ClientStateSummary {
            state: summary.state.map(WlanClientState::from),
            networks: summary
                .networks
                .map(|networks| networks.into_iter().map(|state| state.into()).collect()),
        }
    }
}

/// Serializable credential value for SL4F. The unkown variant should not be used - if an unkown
/// variant shows up somewhere, there may be an issue with the conversion from FIDL value to this.
#[derive(Serialize)]
pub enum Credential {
    Password(String),
    Psk(String),
    None,
    Unknown,
}

impl From<fidl_policy::Credential> for Credential {
    fn from(credential: fidl_policy::Credential) -> Self {
        match credential {
            fidl_policy::Credential::Password(password) => {
                Self::Password(String::from_utf8_lossy(&password).to_string())
            }
            fidl_policy::Credential::Psk(psk) => Self::Psk(hex::encode(psk)),
            fidl_policy::Credential::None(_) => Self::None,
            _ => Self::Unknown,
        }
    }
}

impl Credential {
    fn get_type(&self) -> String {
        match self {
            Credential::Password(_) => "Password",
            Credential::Psk(_) => "Psk",
            Credential::None => "None",
            Credential::Unknown => "Unknown",
        }
        .to_string()
    }

    fn into_value(self) -> String {
        match self {
            Credential::Password(password) => password,
            Credential::Psk(psk) => psk,
            _ => String::new(),
        }
    }
}

impl From<fidl_policy::NetworkIdentifier> for NetworkIdentifier {
    fn from(id: fidl_policy::NetworkIdentifier) -> Self {
        Self { ssid: String::from_utf8_lossy(&id.ssid).to_string(), type_: id.type_.into() }
    }
}

impl From<fidl_policy::SecurityType> for SecurityType {
    fn from(security: fidl_policy::SecurityType) -> Self {
        match security {
            fidl_policy::SecurityType::None => SecurityType::None,
            fidl_policy::SecurityType::Wep => SecurityType::Wep,
            fidl_policy::SecurityType::Wpa => SecurityType::Wpa,
            fidl_policy::SecurityType::Wpa2 => SecurityType::Wpa2,
            fidl_policy::SecurityType::Wpa3 => SecurityType::Wpa3,
        }
    }
}

/// A NetworkConfig that is SL4F friendly and easier to use in tests. Byte vector fields are
/// Strings instead so that tests can check the values more simply and PSKs are translated
/// into hex.
#[derive(Serialize)]
pub struct NetworkConfig {
    pub ssid: Option<String>,
    pub security_type: Option<SecurityType>,
    pub credential_type: Option<String>,
    pub credential_value: Option<String>,
}

impl From<fidl_policy::NetworkConfig> for NetworkConfig {
    fn from(cfg: fidl_policy::NetworkConfig) -> Self {
        let credential = cfg.credential.map(Credential::from);
        NetworkConfig {
            ssid: cfg.id.as_ref().map(|id| String::from_utf8_lossy(&id.ssid).to_string()),
            security_type: cfg.id.map(|id| SecurityType::from(id.type_)),
            credential_type: credential.as_ref().map(|credential| credential.get_type()),
            credential_value: credential.map(|credential| credential.into_value()),
        }
    }
}