use async_trait::async_trait;
use std::collections::HashMap;
use std::path::Path;
use std::{path::PathBuf, str::FromStr};
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;
use unleash_types::client_features::ClientFeatures;

use crate::types::EdgeToken;
use crate::{
    error::EdgeError,
    types::{EdgeResult, TokenRefresh},
};

use super::EdgePersistence;

pub struct FilePersister {
    pub storage_path: PathBuf,
}

impl TryFrom<&str> for FilePersister {
    type Error = EdgeError;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        PathBuf::from_str(value)
            .map(|path| Self { storage_path: path })
            .map_err(|_e| {
                EdgeError::PersistenceError(format!("Could not build a path from {value}"))
            })
    }
}

impl FilePersister {
    pub fn token_path(&self) -> PathBuf {
        let mut token_path = self.storage_path.clone();
        token_path.push("unleash_tokens.json");
        token_path
    }

    pub fn features_path(&self) -> PathBuf {
        let mut features_path = self.storage_path.clone();
        features_path.push("unleash_features.json");
        features_path
    }

    pub fn refresh_target_path(&self) -> PathBuf {
        let mut refresh_target_path = self.storage_path.clone();
        refresh_target_path.push("unleash_refresh_targets.json");
        refresh_target_path
    }

    pub fn new(storage_path: &Path) -> Self {
        let _ = std::fs::create_dir_all(storage_path);
        FilePersister {
            storage_path: storage_path.to_path_buf(),
        }
    }
}

#[async_trait]
impl EdgePersistence for FilePersister {
    async fn load_tokens(&self) -> EdgeResult<Vec<EdgeToken>> {
        let mut file = tokio::fs::File::open(self.token_path())
            .await
            .map_err(|_| {
                EdgeError::PersistenceError(
                    "Cannot load tokens from backup, opening backup file failed".to_string(),
                )
            })?;

        let mut contents = vec![];

        file.read_to_end(&mut contents).await.map_err(|_| {
            EdgeError::PersistenceError(
                "Cannot load tokens from backup, reading backup file failed".to_string(),
            )
        })?;
        serde_json::from_slice(&contents).map_err(|_| {
            EdgeError::PersistenceError(
                "Cannot load tokens from backup, parsing backup file failed".to_string(),
            )
        })
    }

    async fn save_tokens(&self, tokens: Vec<EdgeToken>) -> EdgeResult<()> {
        let mut file = tokio::fs::File::create(self.token_path())
            .await
            .map_err(|_| {
                EdgeError::PersistenceError(
                    "Cannot write tokens to backup. Opening backup file for writing failed"
                        .to_string(),
                )
            })?;
        file.write_all(
            &serde_json::to_vec(&tokens).map_err(|_| {
                EdgeError::PersistenceError("Failed to serialize tokens".to_string())
            })?,
        )
        .await
        .map_err(|_| EdgeError::PersistenceError("Could not serialize tokens to disc".to_string()))
        .map(|_| ())
    }

    async fn load_features(&self) -> EdgeResult<HashMap<String, ClientFeatures>> {
        let mut file = tokio::fs::File::open(self.features_path())
            .await
            .map_err(|_| {
                EdgeError::PersistenceError(
                    "Cannot load features from backup, opening backup file failed".to_string(),
                )
            })?;

        let mut contents = vec![];

        file.read_to_end(&mut contents).await.map_err(|_| {
            EdgeError::PersistenceError(
                "Cannot load features from backup, reading backup file failed".to_string(),
            )
        })?;
        let contents: Vec<(String, ClientFeatures)> =
            serde_json::from_slice(&contents).map_err(|_| {
                EdgeError::PersistenceError(
                    "Cannot load features from backup, parsing backup file failed".to_string(),
                )
            })?;
        Ok(contents.into_iter().collect())
    }

    async fn save_features(&self, features: Vec<(String, ClientFeatures)>) -> EdgeResult<()> {
        let mut file = tokio::fs::File::create(self.features_path())
            .await
            .map_err(|_| {
                EdgeError::PersistenceError(
                    "Cannot write tokens to backup. Opening backup file for writing failed"
                        .to_string(),
                )
            })?;
        file.write_all(
            &serde_json::to_vec(&features).map_err(|_| {
                EdgeError::PersistenceError("Failed to serialize features".to_string())
            })?,
        )
        .await
        .map_err(|_| EdgeError::PersistenceError("Could not serialize tokens to disc".to_string()))
        .map(|_| ())
    }

    async fn load_refresh_targets(&self) -> EdgeResult<Vec<TokenRefresh>> {
        let mut file = tokio::fs::File::open(self.refresh_target_path())
            .await
            .map_err(|_| {
                EdgeError::PersistenceError(
                    "Cannot load tokens from backup, opening backup file failed".to_string(),
                )
            })?;

        let mut contents = vec![];

        file.read_to_end(&mut contents).await.map_err(|_| {
            EdgeError::PersistenceError(
                "Cannot load tokens from backup, reading backup file failed".to_string(),
            )
        })?;
        serde_json::from_slice(&contents).map_err(|_| {
            EdgeError::PersistenceError(
                "Cannot load tokens from backup, parsing backup file failed".to_string(),
            )
        })
    }
    async fn save_refresh_targets(&self, refresh_targets: Vec<TokenRefresh>) -> EdgeResult<()> {
        let mut file = tokio::fs::File::create(self.refresh_target_path())
            .await
            .map_err(|_| {
                EdgeError::PersistenceError(
                    "Cannot write tokens to backup. Opening backup file for writing failed"
                        .to_string(),
                )
            })?;

        file.write_all(&serde_json::to_vec(&refresh_targets).map_err(|_| {
            EdgeError::PersistenceError("Failed to serialize refresh tokens".to_string())
        })?)
        .await
        .map_err(|_| EdgeError::PersistenceError("Could not serialize tokens to disc".to_string()))
        .map(|_| ())
    }
}

#[cfg(test)]
mod tests {
    use std::env::temp_dir;

    use actix_web::http::header::EntityTag;
    use chrono::Utc;
    use unleash_types::client_features::{ClientFeature, ClientFeatures};

    use crate::persistence::file::FilePersister;
    use crate::persistence::EdgePersistence;
    use crate::types::{EdgeToken, TokenRefresh, TokenType, TokenValidationStatus};

    #[tokio::test]
    async fn file_persister_can_save_and_load_features() {
        let persister = FilePersister::try_from(temp_dir().to_str().unwrap()).unwrap();
        let client_features = ClientFeatures {
            features: vec![
                ClientFeature {
                    name: "test1".to_string(),
                    enabled: true,
                    strategies: Some(vec![]),
                    variants: None,
                    project: Some("default".to_string()),
                    feature_type: Some("experiment".to_string()),
                    description: Some("For testing".to_string()),
                    created_at: None,
                    last_seen_at: None,
                    stale: Some(false),
                    impression_data: Some(false),
                },
                ClientFeature {
                    name: "test2".to_string(),
                    ..ClientFeature::default()
                },
            ],
            version: 2,
            segments: None,
            query: None,
        };

        let formatted_data = vec![("some-environment".into(), client_features)];

        persister
            .save_features(formatted_data.clone())
            .await
            .unwrap();
        let reloaded = persister.load_features().await.unwrap();
        assert_eq!(reloaded, formatted_data.into_iter().collect());
    }

    #[tokio::test]
    async fn file_persister_can_save_and_load_refresh_targets() {
        let persister = FilePersister::try_from(temp_dir().to_str().unwrap()).unwrap();
        let tokens = vec![
            TokenRefresh {
                token: EdgeToken {
                    token: "default:development:ajsdkajnsdlsan".into(),
                    token_type: Some(TokenType::Client),
                    environment: Some("development".into()),
                    projects: vec!["default".into()],
                    status: TokenValidationStatus::Validated,
                },
                etag: Some(EntityTag::new_weak("1234".into())),
                last_refreshed: Some(Utc::now()),
                last_check: Some(Utc::now()),
            },
            TokenRefresh {
                token: EdgeToken {
                    token: "otherthing:otherthing:aljjsdnasd".into(),
                    ..EdgeToken::default()
                },
                etag: None,
                last_refreshed: None,
                last_check: None,
            },
        ];

        persister
            .save_refresh_targets(tokens.clone())
            .await
            .unwrap();

        let reloaded = persister.load_refresh_targets().await.unwrap();

        assert_eq!(reloaded, tokens);
    }

    #[tokio::test]
    async fn file_persister_can_save_and_load_tokens() {
        let persister = FilePersister::try_from(temp_dir().to_str().unwrap()).unwrap();
        let tokens = vec![
            EdgeToken {
                token: "default:development:ajsdkajnsdlsan".into(),
                token_type: Some(TokenType::Client),
                environment: Some("development".into()),
                projects: vec!["default".into()],
                status: TokenValidationStatus::Validated,
            },
            EdgeToken {
                token: "otherthing:otherthing:aljjsdnasd".into(),
                ..EdgeToken::default()
            },
        ];

        persister.save_tokens(tokens.clone()).await.unwrap();

        let reloaded = persister.load_tokens().await.unwrap();

        assert_eq!(reloaded, tokens);
    }
}