//
// 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 uuid::Uuid;
use wildland_crypto::identity::SigningKeypair;

use crate::catlib_service::entities::{
    CatlibContainerFilter,
    ContainerPath,
    Devices,
    ForestManifest,
    WildlandPubKey,
};
use crate::catlib_service::error::{CatlibError, CatlibResult};
use crate::rendered_storage::RenderedStorage;
use crate::{
    Container,
    ContainerData,
    CoreXError,
    ErrContext,
    Storage,
    StorageTemplate,
    TemplateContext,
    WildlandIdentity,
};

#[derive(Debug, Clone, PartialEq)]
pub struct ForestIdentity {
    pub index: u64,
    pub keypair: Arc<SigningKeypair>,
}

impl ForestIdentity {
    pub fn new(index: u64, keypair: SigningKeypair) -> Self {
        Self {
            index,
            keypair: Arc::new(keypair),
        }
    }
}

impl From<ForestIdentity> for WildlandIdentity {
    fn from(value: ForestIdentity) -> Self {
        WildlandIdentity::Forest(
            value.index,
            SigningKeypair::try_from_bytes_slices(value.keypair.public(), value.keypair.secret())
                .unwrap(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct Forest {
    forest_manifest: Arc<dyn ForestManifest>,
    identity: ForestIdentity,
}

impl Forest {
    pub fn new(forest_manifest: Arc<dyn ForestManifest>, identity: ForestIdentity) -> Self {
        Self {
            forest_manifest,
            identity,
        }
    }

    /// Returns vector of forest's storage templates
    ///
    #[tracing::instrument(level = "debug", skip_all)]
    pub fn get_storage_templates(&self) -> CatlibResult<Vec<StorageTemplate>> {
        self.forest_manifest
            .get_storage_templates()?
            .into_iter()
            .map(|(uuid, data)| {
                serde_json::from_slice::<StorageTemplate>(&data)
                    .map_err(|e| CatlibError::InvalidDataError(e.to_string()))
                    .map(|t| t.with_catlib_uuid(uuid))
            })
            .collect::<Result<_, CatlibError>>()
    }

    pub fn save_storage_template(
        &self,
        storage_template: StorageTemplate,
    ) -> CatlibResult<(Uuid, StorageTemplate)> {
        let uuid = self.forest_manifest.save_storage_template(
            storage_template.catlib_uuid(),
            serde_json::to_string(&storage_template)
                .map_err(|e| {
                    CatlibError::InvalidDataError(format!("Could not serialize object: {e}"))
                })?
                .into(),
        )?;
        Ok((uuid, storage_template.with_catlib_uuid(uuid)))
    }

    pub fn forest_manifest(&self) -> Arc<dyn ForestManifest> {
        self.forest_manifest.clone()
    }

    pub fn identity(&self) -> &ForestIdentity {
        &self.identity
    }

    /// ## 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 std::collections::HashMap;
    /// # use wildland_corex::catlib_service::entities::WildlandPubKey;
    /// # use wildland_corex::StorageTemplate;
    /// # use wildland_corex::catlib_service::interface::CatLib;
    /// # use wildland_corex::Forest;
    /// # use wildland_corex::ForestIdentity;
    /// # use wildland_corex::SigningKeypair;
    /// # 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 name1".to_owned(), &storage_template, path, false, "".into()).unwrap();
    /// ```
    #[tracing::instrument(level = "debug", skip_all)]
    pub fn create_container(
        &self,
        container_name: String,
        storage_template: &StorageTemplate,
        path: ContainerPath,
        encrypted: bool,
        metadata: Vec<u8>,
    ) -> Result<Container, CoreXError> {
        let container_uuid = Uuid::new_v4();

        let RenderedStorage {
            name,
            backend_type,
            data,
        } = {
            let template_context = TemplateContext {
                container_name: container_name.clone(),
                owner: self.forest_manifest.owner().hex_encode(),
                access_mode: crate::StorageAccessMode::ReadWrite,
                container_uuid,
                path: path.clone(),
            };
            storage_template.render(template_context).map_err(|e| {
                CoreXError::Generic(format!(
                    "Template render error while creating a container: {e}"
                ))
            })?
        };

        let serialized_storage_specific_data = serde_json::to_value(data).map_err(|e| {
            CoreXError::Generic(format!("Could not serialize rendered storage data: {e}"))
        })?;

        let storage = Storage::new(
            Uuid::new_v4(),
            name,
            backend_type,
            serialized_storage_specific_data,
            encrypted,
            storage_template.catlib_uuid(),
        );

        let container_data = ContainerData {
            name: container_name,
            metadata,
        };

        Ok(Container::new(
            self.forest_manifest
                .create_container(container_uuid, container_data.into(), path, vec![storage])
                .context("Could not create a container in catlib")?,
        ))
    }

    #[tracing::instrument(level = "trace")]
    pub fn find_containers(
        &self,
        filter: Option<CatlibContainerFilter>,
    ) -> Result<Vec<Container>, CatlibError> {
        let containers = self.forest_manifest.find_containers(filter)?;
        Ok(containers.into_iter().map(Container::new).collect())
    }

    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to save to the database.
    pub fn add_device(&mut self, device: WildlandPubKey) -> Result<bool, CatlibError> {
        self.forest_manifest.add_device(device, "".into()) // TODO CARGO-213
    }

    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to save to the database.
    #[tracing::instrument(level = "debug", skip_all)]
    pub fn delete_device(&self, device: WildlandPubKey) -> Result<bool, CatlibError> {
        self.forest_manifest.delete_device(device)
    }

    /// Gets the current collection of the Forest's devices.
    ///
    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to sync to the database.
    pub fn devices(&mut self) -> Result<Devices, CatlibError> {
        self.forest_manifest.devices()
    }

    /// ## Errors
    ///
    /// Returns `RedisError` cast on [`crate::catlib_service::error::CatlibResult`] upon failure to save to the database.
    #[tracing::instrument(level = "debug", skip_all)]
    pub fn remove(self) -> Result<bool, CatlibError> {
        self.forest_manifest.delete()
    }

    pub fn owner(&self) -> WildlandPubKey {
        self.forest_manifest.owner()
    }
}