//
// Wildland Project
//
// Copyright © 2022 Golem Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3 as published by
// the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

use std::sync::Arc;

use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::catlib_service::entities::ContainerManifest;
use crate::catlib_service::error::CatlibError;
use crate::rendered_storage::RenderedStorage;
use crate::{
    CoreXError,
    ErrContext,
    Storage,
    StorageTemplate,
    StorageTemplateError,
    TemplateContext,
};

/// Arbitrary container's data that is written to Catlib as bytes (Vec<u8>)
/// In general it should contain the data that is not relevant from Catlib perspective.
#[derive(Debug, Serialize, Deserialize)]
pub struct ContainerData {
    pub name: String,
    pub metadata: Vec<u8>,
}

impl From<ContainerData> for Vec<u8> {
    fn from(value: ContainerData) -> Self {
        serde_json::to_vec(&value).unwrap()
    }
}

impl TryFrom<&[u8]> for ContainerData {
    type Error = String;

    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
        serde_json::from_slice(value).map_err(|e| e.to_string())
    }
}

#[derive(Clone, Debug)]
pub struct Container {
    container_manifest: Arc<dyn ContainerManifest>,
}

impl Container {
    pub fn new(container_manifest: Arc<dyn ContainerManifest>) -> Self {
        Self { container_manifest }
    }

    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to save to the database.
    ///
    /// ## Example
    /// ```no_run
    /// # use wildland_catlib::gql_catlib::GqlCatlib;
    /// # use wildland_corex::catlib_service::interface::CatLib;
    /// # use std::collections::HashMap;
    /// # use wildland_corex::catlib_service::entities::WildlandPubKey;
    /// # use wildland_corex::StorageTemplate;
    /// # use wildland_corex::SigningKeypair;
    /// # use wildland_corex::Forest;
    /// # use wildland_corex::ForestIdentity;
    /// # use wildland_corex::ValidatedTemplateData;
    /// # use uuid::Uuid;
    /// let catlib = GqlCatlib::new("http://localhost:8000/graphql/");
    /// let forest = catlib.create_forest(
    ///                  WildlandPubKey([1; 32]),
    ///                  HashMap::from([(WildlandPubKey([2; 32]), "".into())]),
    ///                  vec![],
    ///              ).unwrap();
    /// let forest = Forest::new(forest, ForestIdentity::new(0, SigningKeypair::try_from_bytes_slices([0;32], [0;32]).unwrap()));
    /// let storage_template = StorageTemplate::new(
    ///     "template type",
    ///     ValidatedTemplateData(
    ///         serde_json::to_value(
    ///             HashMap::from(
    ///                 [
    ///                     (
    ///                         "field1".to_owned(),
    ///                         "Some value with container name: {{ CONTAINER_NAME }}".to_owned(),
    ///                     ),
    ///                     (
    ///                         "parameter in key: {{ OWNER }}".to_owned(),
    ///                         "enum: {{ ACCESS_MODE }}".to_owned(),
    ///                     ),
    ///                     ("uuid".to_owned(), "{{ CONTAINER_UUID }}".to_owned()),
    ///                     ("path".to_owned(), "{{ PATH }}".to_owned()),
    ///                 ]
    ///             )
    ///         ).unwrap()),
    ///         None,
    ///     );
    /// let path = "/some/path".into();
    /// let container = forest.create_container("container name2".to_owned(), &storage_template, path, false, "".into()).unwrap();
    /// ```
    pub fn change_path(&self, path: String) -> Result<(), CatlibError> {
        self.container_manifest.change_path(path.into())
    }

    /// Returns the current claimed path claimed by the given container.
    ///
    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to save to the database.
    ///
    pub fn get_path(&self) -> Result<String, CatlibError> {
        self.container_manifest
            .get_path()
            .map(|path| path.to_string_lossy().to_string())
    }

    /// ## Errors
    ///
    /// - Returns [`CatlibError::NoRecordsFound`] if no [`Container`] was found.
    ///
    pub fn add_storage(
        &mut self,
        template_uuid: Option<Uuid>,
        rendered_storage: RenderedStorage,
        encrypted: bool,
    ) -> Result<Storage, CatlibError> {
        let storage = Storage::new(
            Uuid::new_v4(),
            rendered_storage.name,
            rendered_storage.backend_type,
            rendered_storage.data,
            encrypted,
            template_uuid,
        );

        self.container_manifest.add_storage((&storage).into())?;

        Ok(storage)
    }

    /// ## Errors
    ///
    /// - Returns [`CatlibError::NoRecordsFound`] if no storage was found.
    ///
    pub fn remove_storage(&mut self, uuid: &Uuid) -> Result<(), CoreXError> {
        let mut storages = self.get_storages()?;

        if let Some(position) = storages.iter().position(|s| s.uuid() == *uuid) {
            storages.remove(position);

            self.container_manifest
                .overwrite_storages(storages.iter().map(Into::into).collect())
                .context("Overwriting storages failed")
        } else {
            Err(CoreXError::Generic(
                "No storage found with the provided uuid".into(),
            ))
        }
    }

    pub fn render_template(
        &self,
        storage_template: &StorageTemplate,
    ) -> Result<RenderedStorage, StorageTemplateError> {
        let template_context = TemplateContext {
            container_name: self.name().context("Could not retrieve container's name")?,
            owner: self
                .container_manifest
                .owner()
                .context("Could not retrieve container's owner")?
                .hex_encode(),
            access_mode: crate::StorageAccessMode::ReadWrite,
            container_uuid: self.container_manifest.uuid(),
            path: self
                .container_manifest
                .get_path()
                .context("Could not retrieve container's path")?,
        };
        storage_template.render(template_context)
    }

    /// ## Errors
    ///
    /// Returns [`CatlibError::NoRecordsFound`] if Forest has no [`crate::Storage`].
    pub fn get_storages(&self) -> Result<Vec<Storage>, CoreXError> {
        self.container_manifest
            .get_storages()
            .context("Failed to fetch storages")?
            .into_iter()
            .map(|storage_bytes| {
                Storage::try_from(storage_bytes.as_slice())
                    .map_err(|e| CoreXError::Generic(e.to_string()))
            })
            .collect::<Result<_, _>>()
    }

    /// Updates a tet name of the given container.
    ///
    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to save to the database.
    pub fn set_name(&self, name: String) -> Result<(), CatlibError> {
        let mut data = ContainerData::try_from(self.container_manifest.data()?.as_slice())
            .map_err(CatlibError::InvalidDataError)?;
        data.name = name;
        self.container_manifest.set_data(data.into())
    }

    /// Get the container's name
    ///
    pub fn name(&self) -> Result<String, CatlibError> {
        Ok(
            serde_json::from_slice::<ContainerData>(&self.container_manifest.data()?)
                .map_err(|e| CatlibError::InvalidDataError(e.to_string()))?
                .name,
        )
    }

    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to save to the database.
    pub fn remove(&self) -> Result<(), CatlibError> {
        self.container_manifest.delete()
    }

    /// Get the container's uuid
    ///
    pub fn uuid(&self) -> Uuid {
        self.container_manifest.uuid()
    }

    pub fn metadata(&self) -> Result<Vec<u8>, CatlibError> {
        Ok(
            ContainerData::try_from(self.container_manifest.data()?.as_slice())
                .map_err(CatlibError::InvalidDataError)?
                .metadata,
        )
    }

    pub fn set_metadata(&self, metadata: Vec<u8>) -> Result<(), CatlibError> {
        let mut data = ContainerData::try_from(self.container_manifest.data()?.as_slice())
            .map_err(CatlibError::InvalidDataError)?;
        data.metadata = metadata;
        self.container_manifest.set_data(data.into())
    }
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use crate::catlib_service::entities::{ContainerPath, MockContainerManifest};
    use crate::*;

    fn make_container(path: ContainerPath) -> Container {
        let mut container_manifest = MockContainerManifest::new();
        container_manifest
            .expect_get_path()
            .returning(move || Ok(path.clone()));
        Container::new(Arc::new(container_manifest))
    }

    #[test]
    fn new_container_should_has_at_least_one_storage_and_path() {
        let container = make_container("/some/path".into());
        let path = container.get_path().unwrap();
        assert_eq!(path, "/some/path");
    }
}