pub fn container_chain_genesis_data_from_path(path: &str) -> ContainerChainGenesisDataResult {

    let raw_chainspec_str = std::fs::read_to_string(path)

        .map_err(|_e| format!("ChainSpec for container chain not found at {:?}", path))?;

    container_chain_genesis_data_from_str(&raw_chainspec_str)

}

pub fn container_chain_genesis_data_from_str(

    raw_chainspec_str: &str,

) -> ContainerChainGenesisDataResult {

    let raw_chainspec_json: serde_json::Value =

        serde_json::from_str(raw_chainspec_str).map_err(|e| e.to_string())?;

    container_chain_genesis_data_from_json(&raw_chainspec_json)

}

pub fn container_chain_genesis_data_from_json(

    raw_chainspec_json: &serde_json::Value,

) -> ContainerChainGenesisDataResult {

    // TODO: we are manually parsing a json file here, maybe we can leverage the existing

    // chainspec deserialization code.

    // TODO: this bound checking may panic, but that shouldn't be too dangerous because this

    // function is only used by the `build-spec` command.

    let para_id: u32 = u32::try_from(raw_chainspec_json["para_id"].as_u64().unwrap()).unwrap();

    let name: String = raw_chainspec_json["name"].as_str().unwrap().to_owned();

    let id: String = raw_chainspec_json["id"].as_str().unwrap().to_owned();

    let fork_id: Option<String> = raw_chainspec_json["fork_id"].as_str().map(|x| x.to_owned());

    let genesis_raw_top_json = &raw_chainspec_json["genesis"]["raw"]["top"];

    let storage = storage_from_chainspec_json(genesis_raw_top_json)?;

    let properties_json = &raw_chainspec_json["properties"];

    let properties = properties_from_chainspec_json(properties_json);

    let boot_nodes: Vec<serde_json::Value> =

        raw_chainspec_json["bootNodes"].as_array().unwrap().clone();

    let boot_nodes: Vec<Vec<u8>> = boot_nodes

        .into_iter()

        .map(|x| {

            let bytes = x.as_str().unwrap().as_bytes();

            bytes.to_vec()

        })

        .collect();

    Ok((

        para_id.into(),

        ContainerChainGenesisData {

            storage,

            name: name.into(),

            id: id.into(),

            fork_id: fork_id.map(|x| x.into()),

            extensions: vec![],

            properties,

        },

        boot_nodes,

    ))

}

pub fn storage_from_chainspec_json(

    genesis_raw_top_json: &serde_json::Value,

) -> Result<Vec<ContainerChainGenesisDataItem>, String> {

    let genesis_data_map = genesis_raw_top_json

        .as_object()

        .ok_or("genesis.raw.top is not an object".to_string())?;

    let mut genesis_data_vec = Vec::with_capacity(genesis_data_map.len());

    for (key, value) in genesis_data_map {

        let key_hex = key

            .strip_prefix("0x")

            .ok_or("key does not start with 0x".to_string())?;

        let value = value.as_str().ok_or("value is not a string".to_string())?;

        let value_hex = value

            .strip_prefix("0x")

            .ok_or("value does not start with 0x".to_string())?;

        let key_bytes = hex::decode(key_hex).map_err(|e| e.to_string())?;

        let value_bytes = hex::decode(value_hex).map_err(|e| e.to_string())?;

        genesis_data_vec.push((key_bytes, value_bytes).into());

    genesis_data_vec.sort_unstable();

    Ok(genesis_data_vec)

}

pub fn properties_from_chainspec_json(properties_json: &serde_json::Value) -> Properties {

    let mut properties: Properties = Properties::default();

    if let Some(x) = properties_json

        .get("ss58Format")

        .and_then(|x| u32::try_from(x.as_u64()?).ok())

        .or_else(|| {

            log::warn!(

                "Failed to read properties.ss58Format from container chain chain spec, using default value instead. Invalid value was: {:?}",

                properties_json.get("ss58Format")

            None

        })

    {

        properties.token_metadata.ss58_format = x;

    }

    if let Some(x) = properties_json

        .get("tokenDecimals")

        .and_then(|x: &serde_json::Value| u32::try_from(x.as_u64()?).ok()).or_else(|| {

            log::warn!(

                "Failed to read properties.tokenDecimals from container chain chain spec, using default value instead. Invalid value was: {:?}",

                properties_json.get("tokenDecimals")

            None

        })

    {

        properties.token_metadata.token_decimals = x;

    }

    if let Some(x) = properties_json.get("tokenSymbol").and_then(|x| {

        let xs = x.as_str()?;

        let xv: Vec<u8> = xs.to_string().into();

        xv.try_into().ok()

    }).or_else(|| {

        log::warn!(

            "Failed to read properties.tokenSymbol from container chain chain spec, using default value instead. Invalid value was: {:?}",

            properties_json.get("tokenSymbol")

        None

    }) {

        properties.token_metadata.token_symbol = x;

    }

    if let Some(x) = properties_json.get("isEthereum").and_then(|x| {

        x.as_bool()

    }).or_else(|| {

        log::warn!(

            "Failed to read properties.isEthereum from container chain chain spec, using default value instead. Invalid value was: {:?}",

            properties_json.get("isEthereum")

        None

    }) {

        properties.is_ethereum = x;

    }

    properties

}

pub fn properties_to_map(

    properties: &Properties,

) -> Result<serde_json::Map<String, serde_json::Value>, String> {

    let properties = vec![

        (

            "ss58Format",

            serde_json::Value::from(properties.token_metadata.ss58_format),

        ),

        (

            "tokenDecimals",

            serde_json::Value::from(properties.token_metadata.token_decimals),

        ),

        (

            "tokenSymbol",

            serde_json::Value::from(

                String::from_utf8(properties.token_metadata.token_symbol.to_vec())

                    .map_err(|e| format!("tokenSymbol is not valid UTF8: {}", e))?,

        (

            "isEthereum",

            serde_json::Value::from(properties.is_ethereum),

        ),

    ]

    .into_iter()

    .map(|(k, v)| (k.to_string(), v))

    .collect();

    Ok(properties)

}