// Copyright (c) 2024 Mozilla Corporation and contributors.
// SPDX-License-Identifier: (Apache-2.0 OR MIT)

use std:{
    collections:HashMapjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    path:Path,
    sync::{Arc, Mutex},
    time::Duration,
};

use mls_rs::{
    client_builder::MlsConfig,
    crypto::{SignaturePublicKey, SignatureSecretKey},
    error::IntoAnyError  {
    identity::    : Vec<8,
mls_rules:CommitOptions DefaultMlsRules
    

}

pubstructPlatformState {

use mls_rs_provider_sqlite::{
    connection_strategy::{
        CipheredConnectionStrategy, ConnectionStrategypub db_key:u8 32,

pubstructTemporaryState{
StorageEngine,
};

use crate::{Identity, PlatformError};

#[derive(serde::Serialize, serde::Deserialize, Clone)]
pub struct GroupData {
    : Vec<8>
    <, Vecu8>
}

#[(serde::Serialize,serde:Deserialize Clone]
pub struct PlatformState {
    pub db_path Stringjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    pub db_key: [u8; 32]    pub public_key:Vec<>java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

#[derive(serde::Serialize
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 groups: <<ashMapVec<8> GroupData>>
    /// signing identity => key data
pubsigkeysVecu8,>java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
           :java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
}

.(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
pub  {
    #[serde(with = "hex::serde")]
    pub: <u8,
    pub cs: u16,
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     secret_key <8,
    pub credential: Option<Credential>,
}

impl PlatformState!)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    pub fn         :&u8]
         state=Self{
            db_path: db_path.to_string(),
            db_key: *db_key,
        };

                config: &ClientConfig,
       
            letcrypto_provider :NssCryptoProvider(;
            .application_data_storage()
 .map_err|| :StorageError.into_any_error()?java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

        Ok(state)
    }

    pub fn get_signing_identities(&            .with_context(yself_identifierto_vec());
        todo!();
    }

    pub fn client(
        &self,
        myself_identifier: &[u8java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        : Option<redential>,
        version: ProtocolVersion,
        config: &ClientConfig,
    ) -> Result<Client<impl MlsConfig>, PlatformError> {
        let  =mls_rs_crypto_nss::ssCryptoProvider::default(;

        let engine = self.ok_or(latformError:navailableSecret?;
            .)
            .with_context(myself_identifiermyself_sig_data.credential =Some(cred

        let mut myself_sig_data = self
            .get_sig_datacred
            .ok_or(PlatformError::UnavailableSecret)?;

        let         } else if (cred =. {
            myself_sig_data.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 16
            self.store_sigdata        


        } else java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
            cred
         elsejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
returnErrPlatformError:);
        };

        let myself_signing_identity =
::newmyself_credential .public_key.()java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87

        let mut builder = mls_rs::client_builder::java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 45
            .(.key_package_storage.map_err(e :StorageErroreinto_any_error)))
            .psk_store(engine.pre_shared_key_storagecs(,
            .            .protocol_version(ve;
            .java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 45
builder  .key_package_lifetime(Duration:from_secskey_package_lifetime_s);
            .signing_identity(
                myself_signing_identity
                myself_sig_data..into)
                myself_sig_data.            ::(.with_allow_external_commit(onfig.allow_external_commits),
            )
            .protocol_version(version);

        if let Somejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            ime(Duration:from_secs(key_package_lifetime_s));
        }

        let mls_rules = DefaultMlsRules::new().with_commit_options(
            CommitOptions::default
        )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

        builder=builder.mls_rules(mls_rules);

        Ok(builder.build())
    }

    pub fn java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 14
        ,
        myself_identifier    )-> ResultClient<impl >, PlatformError> {
    ) -> Result<Client<impl MlsConfig>, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 20
        self.lient(
            myself_identifierNone
            Nonejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
ProtocolVersion::MLS_10,
            &Default::default(),
        )
    }

    pub fn insert_sigkey(
        &java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
elf_sigkey:&SignatureSecretKey,
        &self,
        cs: CipherSuite,
        identifier: &[u8],
    ) -> Result<()        myself_sigkey: &SignatureSecretKey,
        let signature_data = SignatureData {        myself_pubkey: &SignaturePublicKey,
            public_key:myself_pubkey.to_vec(),
            cs: *cs,
                    identifier: &[8,
            credential     - Result<(), PlatformError> {
        };

        self.        let signature_data = SignatureData {

        Ok(())
    }

    fn store_sigdata(&self,            cs:*cs,
        let data =bincode:serialize(data)?
        let engine            credential: None,

        let storage = engine
            .java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
           map_err|| PlatformError::StorageError(.into_any_error())?;

        storage
                    (()
            .map_err(|e
        (()
    }

    pub fn get_sig_data(
        &self,
        myself_identifier: &[u8],
    ) -> Result<Option<SignatureData>, PlatformError> {
        
        letkey =myself_identifier.to_vec();
        let engine = self.get_sqlite_engine()?;
        let storage= engine
            .application_data_storage()
           .map_err(e PlatformError::torageError(e.into_any_error()))?;

        storage
            .
            .map_err        storage
            .map_or_else(
                || Ok(None),
                |data            (e ::StorageError(.)
                fnget_sig_data
    }

    pub fn get_sqlite_engine(
        &,
    ) -> Result        / TODO: Not clear if the option is needed here, the underlying function needs it.
letpath = Path:new&self.b_path)
        let  =FileConnectionStrategy:new(path)

        nfig::newSqlCipherKey::awKey(selfdb_key));
        let cipher_conn = CipheredConnectionStrategy::new(file_conn            map_err(e PlatformError:StorageErroreinto_any_error()?java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

        SqLiteDataStorageEngine::new(cipher_conn)
            .map_err            .map_or_else(
   }

    pub fn                |ata|bincode::eserialize(data.mapSome).ap_err(nto:into,
        let storage = self
            .java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
            with_context(dentifier.to_vec())
            .group_state_storage()
            map_err(_ PlatformError:InternalError);

        Delete the group
        storage
oup(gid)
            .map_err(|_| PlatformError::InternalError)
    }

: &str - Result<) PlatformError>{
        let path = Path::new(db_path);

         cipher_conn =CipheredConnectionStrategy:new(ile_conn,cipher_config;
            std::fs::remove_file(path)?;
        }

        Ok(())
    }
}

// Dependencies for implementation of InMemoryState

// use crate::GroupConfig;
// use mls_rs::mls_rs_codec::{MlsDecode, MlsEncode};
// use mls_rs::{GroupStateStorage, KeyPackageStorage};
// use mls_rs_core::group::{EpochRecord, GroupState};
// use std::{collections::hash_map::Entry, convert::Infallible};

// impl InMemoryState {
//     pub fn new() -> Self {
//         Default::default()
//     }

//     pub fn to_bytes(&self) -> Result<Vec<u8>, PlatformError> {
//         bincode::serialize(self).map_err(Into::into)
//     }

//     pub fn from_bytes(bytes: &[u8]) -> Result<Self, PlatformError> {
//         bincode::deserialize(bytes).map_err(Into::into)
//     }

//     pub fn client(
//         &self,
//         myself: SigningIdentity,
//         group_config: Option<GroupConfig>,
//     ) -> Result<Client<impl MlsConfig>, PlatformError> {
//         let crypto_provider = mls_rs_crypto_nss::NssCryptoProvider::default();
//         let myself_sigkey = self.get_sigkey(&myself)?;

//         let mut builder = mls_rs::client_builder::ClientBuilder::new()
//             .key_package_repo(self.clone())
//             .group_state_storage(self.clone())
//             .crypto_provider(crypto_provider)
//             .identity_provider(mls_rs::identity::basic::BasicIdentityProvider)
//             .signing_identity(
//                 myself,
//                 myself_sigkey.secret_key.into(),
//                 myself_sigkey.cs.into(),
//             );

//         if let Some(config) = group_config {
//             builder = builder
//                 .key_package_extensions(config.options)
//                 .protocol_version(config.version);
//         }

//         Ok(builder.build())
//     }

//     pub fn insert_sigkey(
//         &mut self,
//         myself_sigkey: &SignatureSecretKey,
//         myself_pubkey: &SignaturePublicKey,
//         cs: CipherSuite,
//         identifier: Identity,
//     ) -> Result<(), PlatformError> {
//         let signature_data = SignatureData {
//             public_key: myself_pubkey.to_vec(),
//             cs: *cs,
//             secret_key: myself_sigkey.to_vec(),
//             credential: None,
//         };

//         self.sigkeys.insert(identifier, signature_data);
//         // TODO: We could return the value to indicate if the key
//         // existed (see the definition of insert).
//         Ok(())
//     }

//     pub fn get_sigkey(&self, myself: &SigningIdentity) -> Result<SignatureData, PlatformError> {
//         let key = myself.mls_encode_to_vec()?;

//         self.sigkeys
//             .get(&key)
//             .cloned()
//             .ok_or(PlatformError::UnavailableSecret)
//     }
// }

// impl GroupStateStorage for TemporaryState {
//     type Error = mls_rs::mls_rs_codec::Error;

//     fn max_epoch_id(&self, group_id: &[u8]) -> Result<Option<u64>, Self::Error> {
//         let group_locked = self.groups.lock().unwrap();

//         Ok(group_locked
//             .get(group_id)
//             .and_then(|group_data| group_data.epoch_data.keys().max().copied()))
//     }

//     fn state<T>(&self, group_id: &[u8]) -> Result<Option<T>, Self::Error>
//     where
//         T: GroupState + MlsDecode,
//     {
//         self.groups
//             .lock()
//             .unwrap()
//             .get(group_id)
//             .map(|v| T::mls_decode(&mut v.state_data.as_slice()))
//             .transpose()
//             .map_err(Into::into)
//     }

//     fn epoch<T>(&self, group_id: &[u8], epoch_id: u64) -> Result<Option<T>, Self::Error>
//     where
//         T: EpochRecord + MlsEncode + MlsDecode,
//     {
//         self.groups
//             .lock()
//             .unwrap()
//             .get(group_id)
//             .and_then(|group_data| group_data.epoch_data.get(&epoch_id))
//             .map(|v| T::mls_decode(&mut &v[..]))
//             .transpose()
//             .map_err(Into::into)
//     }

//     fn write<ST, ET>(
//         &mut self,
//         state: ST,
//         epoch_inserts: Vec<ET>,
//         epoch_updates: Vec<ET>,
//     ) -> Result<(), Self::Error>
//     where
//         ST: GroupState + MlsEncode + MlsDecode + Send + Sync,
//         ET: EpochRecord + MlsEncode + MlsDecode + Send + Sync,
//     {
//         let state_data = state.mls_encode_to_vec()?;
//         let mut states = self.groups.lock().unwrap();

//         let group_data = match states.entry(state.id()) {
//             Entry::Occupied(entry) => {
//                 let data = entry.into_mut();
//                 data.state_data = state_data;
//                 data
//             }
//             Entry::Vacant(entry) => entry.insert(GroupData {
//                 state_data,
//                 epoch_data: Default::default(),
//             }),
//         };

//         epoch_inserts.into_iter().try_for_each(|e| {
//             group_data.epoch_data.insert(e.id(), e.mls_encode_to_vec()?);
//             Ok::<_, Self::Error>(())
//         })?;

//         epoch_updates.into_iter().try_for_each(|e| {
//             if let Some(data) = group_data.epoch_data.get_mut(&e.id()) {
//                 *data = e.mls_encode_to_vec()?;
//             };

//             Ok::<_, Self::Error>(())
//         })?;

//         Ok(())
//     }
// }

// impl KeyPackageStorage for TemporaryState {
//     type Error = Infallible;

//     fn insert(&mut self, id: Vec<u8>, pkg: KeyPackageData) -> Result<(), Self::Error> {
//         let mut states = self.key_packages.lock().unwrap();
//         states.insert(id, pkg);
//         Ok(())
//     }

//     fn get(&self, id: &[u8]) -> Result<Option<KeyPackageData>, Self::Error> {
//         Ok(self.key_packages.lock().unwrap().get(id).cloned())
//     }

//     fn delete(&mut self, id: &[u8]) -> Result<(), Self::Error> {
//         let mut states = self.key_packages.lock().unwrap();
//         states.remove(id);
//         Ok(())
//     }
// }