// Copyright 2015, 2016, 2017 Parity Technologies (UK) Ltd.
// This file is part of Parity.

// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Parity 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 Parity.  If not, see <http://www.gnu.org/licenses/>.

use std::io::{Read, Write};
use serde::{Deserialize, Deserializer, Error};
use serde::de::{Visitor, MapVisitor};
use serde_json;
use serde_json::value::Value;
use serde_json::error;
use super::{Uuid, Version, Crypto, H160};

/// Meta key name for vault field
const VAULT_NAME_META_KEY: &'static str = "vault";

/// Key file as stored in vaults
#[derive(Debug, PartialEq, Serialize)]
pub struct VaultKeyFile {
	/// Key id
	pub id: Uuid,
	/// Key version
	pub version: Version,
	/// Secret, encrypted with account password
	pub crypto: Crypto,
	/// Serialized `VaultKeyMeta`, encrypted with vault password
	pub metacrypto: Crypto,
}

/// Data, stored in `VaultKeyFile::metacrypto`
#[derive(Debug, PartialEq, Serialize)]
pub struct VaultKeyMeta {
	/// Key address
	pub address: H160,
	/// Key name
	pub name: Option<String>,
	/// Key metadata
	pub meta: Option<String>,
}

/// Insert vault name to the JSON meta field
pub fn insert_vault_name_to_json_meta(meta: &str, vault_name: &str) -> Result<String, error::Error> {
	let mut meta = if meta.is_empty() {
		Value::Object(serde_json::Map::new())
	} else {
		serde_json::from_str(meta)?
	};

	if let Some(meta_obj) = meta.as_object_mut() {
		meta_obj.insert(VAULT_NAME_META_KEY.to_owned(), Value::String(vault_name.to_owned()));
		serde_json::to_string(meta_obj)
	} else {
		Err(error::Error::custom("Meta is expected to be a serialized JSON object"))
	}
}

/// Remove vault name from the JSON meta field
pub fn remove_vault_name_from_json_meta(meta: &str) -> Result<String, error::Error> {
	let mut meta = if meta.is_empty() {
		Value::Object(serde_json::Map::new())
	} else {
		serde_json::from_str(meta)?
	};

	if let Some(meta_obj) = meta.as_object_mut() {
		meta_obj.remove(VAULT_NAME_META_KEY);
		serde_json::to_string(meta_obj)
	} else {
		Err(error::Error::custom("Meta is expected to be a serialized JSON object"))
	}
}

enum VaultKeyFileField {
	Id,
	Version,
	Crypto,
	MetaCrypto,
}

enum VaultKeyMetaField {
	Address,
	Name,
	Meta,
}

impl Deserialize for VaultKeyFileField {
	fn deserialize<D>(deserializer: &mut D) -> Result<VaultKeyFileField, D::Error>
		where D: Deserializer
	{
		deserializer.deserialize(VaultKeyFileFieldVisitor)
	}
}

struct VaultKeyFileFieldVisitor;

impl Visitor for VaultKeyFileFieldVisitor {
	type Value = VaultKeyFileField;

	fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E>
		where E: Error
	{
		match value {
			"id" => Ok(VaultKeyFileField::Id),
			"version" => Ok(VaultKeyFileField::Version),
			"crypto" => Ok(VaultKeyFileField::Crypto),
			"metacrypto" => Ok(VaultKeyFileField::MetaCrypto),
			_ => Err(Error::custom(format!("Unknown field: '{}'", value))),
		}
	}
}

impl Deserialize for VaultKeyFile {
	fn deserialize<D>(deserializer: &mut D) -> Result<VaultKeyFile, D::Error>
		where D: Deserializer
	{
		static FIELDS: &'static [&'static str] = &["id", "version", "crypto", "metacrypto"];
		deserializer.deserialize_struct("VaultKeyFile", FIELDS, VaultKeyFileVisitor)
	}
}

struct VaultKeyFileVisitor;

impl Visitor for VaultKeyFileVisitor {
	type Value = VaultKeyFile;

	fn visit_map<V>(&mut self, mut visitor: V) -> Result<Self::Value, V::Error>
		where V: MapVisitor
	{
		let mut id = None;
		let mut version = None;
		let mut crypto = None;
		let mut metacrypto = None;

		loop {
			match visitor.visit_key()? {
				Some(VaultKeyFileField::Id) => { id = Some(visitor.visit_value()?); }
				Some(VaultKeyFileField::Version) => { version = Some(visitor.visit_value()?); }
				Some(VaultKeyFileField::Crypto) => { crypto = Some(visitor.visit_value()?); }
				Some(VaultKeyFileField::MetaCrypto) => { metacrypto = Some(visitor.visit_value()?); }
				None => { break; }
			}
		}

		let id = match id {
			Some(id) => id,
			None => visitor.missing_field("id")?,
		};

		let version = match version {
			Some(version) => version,
			None => visitor.missing_field("version")?,
		};

		let crypto = match crypto {
			Some(crypto) => crypto,
			None => visitor.missing_field("crypto")?,
		};

		let metacrypto = match metacrypto {
			Some(metacrypto) => metacrypto,
			None => visitor.missing_field("metacrypto")?,
		};

		visitor.end()?;

		let result = VaultKeyFile {
			id: id,
			version: version,
			crypto: crypto,
			metacrypto: metacrypto,
		};

		Ok(result)
	}
}

impl Deserialize for VaultKeyMetaField {
	fn deserialize<D>(deserializer: &mut D) -> Result<VaultKeyMetaField, D::Error>
		where D: Deserializer
	{
		deserializer.deserialize(VaultKeyMetaFieldVisitor)
	}
}

struct VaultKeyMetaFieldVisitor;

impl Visitor for VaultKeyMetaFieldVisitor {
	type Value = VaultKeyMetaField;

	fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E>
		where E: Error
	{
		match value {
			"address" => Ok(VaultKeyMetaField::Address),
			"name" => Ok(VaultKeyMetaField::Name),
			"meta" => Ok(VaultKeyMetaField::Meta),
			_ => Err(Error::custom(format!("Unknown field: '{}'", value))),
		}
	}
}

impl Deserialize for VaultKeyMeta {
	fn deserialize<D>(deserializer: &mut D) -> Result<VaultKeyMeta, D::Error>
		where D: Deserializer
	{
		static FIELDS: &'static [&'static str] = &["address", "name", "meta"];
		deserializer.deserialize_struct("VaultKeyMeta", FIELDS, VaultKeyMetaVisitor)
	}
}

struct VaultKeyMetaVisitor;

impl Visitor for VaultKeyMetaVisitor {
	type Value = VaultKeyMeta;

	fn visit_map<V>(&mut self, mut visitor: V) -> Result<Self::Value, V::Error>
		where V: MapVisitor
	{
		let mut address = None;
		let mut name = None;
		let mut meta = None;

		loop {
			match visitor.visit_key()? {
				Some(VaultKeyMetaField::Address) => { address = Some(visitor.visit_value()?); }
				Some(VaultKeyMetaField::Name) => { name = Some(visitor.visit_value()?); }
				Some(VaultKeyMetaField::Meta) => { meta = Some(visitor.visit_value()?); }
				None => { break; }
			}
		}

		let address = match address {
			Some(address) => address,
			None => visitor.missing_field("address")?,
		};

		visitor.end()?;

		let result = VaultKeyMeta {
			address: address,
			name: name,
			meta: meta,
		};

		Ok(result)
	}
}

impl VaultKeyFile {
	pub fn load<R>(reader: R) -> Result<Self, serde_json::Error> where R: Read {
		serde_json::from_reader(reader)
	}

	pub fn write<W>(&self, writer: &mut W) -> Result<(), serde_json::Error> where W: Write {
		serde_json::to_writer(writer, self)
	}
}

impl VaultKeyMeta {
	pub fn load(bytes: &[u8]) -> Result<Self, serde_json::Error> {
		serde_json::from_slice(&bytes)
	}

	pub fn write(&self) -> Result<Vec<u8>, serde_json::Error> {
		let s = serde_json::to_string(self)?;
		Ok(s.as_bytes().into())
	}
}

#[cfg(test)]
mod test {
	use serde_json;
	use json::{VaultKeyFile, Version, Crypto, Cipher, Aes128Ctr, Kdf, Pbkdf2, Prf,
		insert_vault_name_to_json_meta, remove_vault_name_from_json_meta};

	#[test]
	fn to_and_from_json() {
		let file = VaultKeyFile {
			id: "08d82c39-88e3-7a71-6abb-89c8f36c3ceb".into(),
			version: Version::V3,
			crypto: Crypto {
				cipher: Cipher::Aes128Ctr(Aes128Ctr {
					iv: "fecb968bbc8c7e608a89ebcfe53a41d0".into(),
				}),
				ciphertext: "4befe0a66d9a4b6fec8e39eb5c90ac5dafdeaab005fff1af665fd1f9af925c91".into(),
				kdf: Kdf::Pbkdf2(Pbkdf2 {
					c: 10240,
					dklen: 32,
					prf: Prf::HmacSha256,
					salt: "f17731e84ecac390546692dbd4ccf6a3a2720dc9652984978381e61c28a471b2".into(),
				}),
				mac: "7c7c3daafb24cf11eb3079dfb9064a11e92f309a0ee1dd676486bab119e686b7".into(),
			},
			metacrypto: Crypto {
				cipher: Cipher::Aes128Ctr(Aes128Ctr {
					iv: "9c353fb3f894fc05946843616c26bb3f".into(),
				}),
				ciphertext: "fef0d113d7576c1702daf380ad6f4c5408389e57991cae2a174facd74bd549338e1014850bddbab7eb486ff5f5c9c5532800c6a6d4db2be2212cd5cd3769244ab230e1f369e8382a9e6d7c0a".into(),
				kdf: Kdf::Pbkdf2(Pbkdf2 {
					c: 10240,
					dklen: 32,
					prf: Prf::HmacSha256,
					salt: "aca82865174a82249a198814b263f43a631f272cbf7ed329d0f0839d259c652a".into(),
				}),
				mac: "b7413946bfe459d2801268dc331c04b3a84d92be11ef4dd9a507f895e8d9b5bd".into(),
			}
		};

		let serialized = serde_json::to_string(&file).unwrap();
		let deserialized = serde_json::from_str(&serialized).unwrap();

		assert_eq!(file, deserialized);
	}

	#[test]
	fn vault_name_inserted_to_json_meta() {
		assert_eq!(insert_vault_name_to_json_meta(r#""#, "MyVault").unwrap(), r#"{"vault":"MyVault"}"#);
		assert_eq!(insert_vault_name_to_json_meta(r#"{"tags":["kalabala"]}"#, "MyVault").unwrap(), r#"{"tags":["kalabala"],"vault":"MyVault"}"#);
	}

	#[test]
	fn vault_name_not_inserted_to_json_meta() {
		assert!(insert_vault_name_to_json_meta(r#"///3533"#, "MyVault").is_err());
		assert!(insert_vault_name_to_json_meta(r#""string""#, "MyVault").is_err());
	}

	#[test]
	fn vault_name_removed_from_json_meta() {
		assert_eq!(remove_vault_name_from_json_meta(r#"{"vault":"MyVault"}"#).unwrap(), r#"{}"#);
		assert_eq!(remove_vault_name_from_json_meta(r#"{"tags":["kalabala"],"vault":"MyVault"}"#).unwrap(), r#"{"tags":["kalabala"]}"#);
	}

	#[test]
	fn vault_name_not_removed_from_json_meta() {
		assert!(remove_vault_name_from_json_meta(r#"///3533"#).is_err());
		assert!(remove_vault_name_from_json_meta(r#""string""#).is_err());
	}
}