// Rhyoea. Vulkan FFI bindings for Rust
// Copyright © 2019 Adrien Jeser <adrien@jeser.me>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

//! TODO: Doc

use crate::extends::Extends;
use crate::extends::{Extension, Layer};
use crate::instance::bind::{VkApplicationInfo, VkInstanceCreateInfo};
use crate::instance::Result;
use std::ffi::CString;

/// Specifying parameters of a newly created instance
#[derive(Debug, Clone)]
pub(super) struct Information {
    /// Structure specifying parameters of a newly created instance
    pub(super) inner: VkInstanceCreateInfo,

    /// Extensions to enable, in the local state
    extensions_information: ExtendsInformation<Extension>,

    /// Layers to enable, in the local state
    layers_information: ExtendsInformation<Layer>,
}

impl Information {
    /// Create a new instance `Information`
    pub(super) fn new(
        application: &VkApplicationInfo,
        extensions: Vec<Extension>,
        layers: Vec<Layer>,
    ) -> Result<Self> {
        let extensions_information = ExtendsInformation::new(extensions)?;
        let layers_information = ExtendsInformation::new(layers)?;
        let inner =
            VkInstanceCreateInfo::new(application, &extensions_information, &layers_information);

        Ok(Self {
            inner,
            extensions_information,
            layers_information,
        })
    }
}

impl From<Information> for VkInstanceCreateInfo {
    fn from(information: Information) -> Self {
        information.inner
    }
}

/// The `ExtendsInformation` type. See [the module level documentation](index.html) for more
///
/// Specifying extensions parameters of a newly created instance
///
/// It wrap a Vulkan property to be safe
#[derive(Debug, Clone)]
pub struct ExtendsInformation<T: Extends> {
    extends: Vec<T>,
    extends_names: Vec<CString>,
    extends_names_ptr: Vec<*const i8>,
}

impl<T: Extends> ExtendsInformation<T> {
    /// Create a new `ExtendsInformation<T>`
    ///
    /// # Example
    ///
    /// ```
    /// use rhyoea::instance::information::ExtendsInformation;
    /// use rhyoea::extends::{Extends, Extensions};
    /// use rhyoea::result::InstanceError;
    ///
    /// pub fn main() -> Result<(), InstanceError> {
    ///     let extensions = Extensions::available();
    ///     let _ = ExtendsInformation::new(extensions);
    ///     Ok(())
    /// }
    /// ```
    pub fn new(extends: Vec<T>) -> Result<Self> {
        let extends_names: std::result::Result<Vec<_>, _> = extends
            .iter()
            .map(|property| CString::new(property.name().clone()))
            .collect();
        let extends_names = extends_names?;
        let extends_names_ptr: Vec<_> = extends_names.iter().map(|q| q.as_ptr()).collect();

        Ok(Self {
            extends,
            extends_names,
            extends_names_ptr,
        })
    }

    /// Returns a raw pointer to the underlying data
    ///
    ///
    /// # Safety
    ///
    /// TODO: Doc
    ///
    /// # Example
    ///
    /// ```
    /// use rhyoea::instance::information::ExtendsInformation;
    /// use rhyoea::extends::{Extends, Extensions};
    /// use rhyoea::result::InstanceError;
    ///
    /// let extensions = Extensions::available();
    /// let extensions_extends = ExtendsInformation::new(extensions)?;
    ///
    /// unsafe {
    ///   assert_ne!(std::ptr::null(), extensions_extends.as_ptr());
    /// }
    ///
    /// # Ok::<(), InstanceError>(())
    /// ```
    #[must_use]
    pub unsafe fn as_ptr(&self) -> *const *const i8 {
        self.extends_names_ptr.as_ptr()
    }

    /// Returns the number of elements in the property vector, also referred to as its 'length'
    ///
    /// # Example
    ///
    /// ```
    /// use rhyoea::instance::information::ExtendsInformation;
    /// use rhyoea::extends::{Extends, Extensions};
    /// use rhyoea::result::InstanceError;
    ///
    /// let extensions = Extensions::available();
    /// let extensions_extends = ExtendsInformation::new(extensions)?;
    /// assert!(extensions_extends.len() > 0);
    ///
    /// # Ok::<(), InstanceError>(())
    /// ```
    #[cfg_attr(feature = "cargo-clippy", allow(clippy::cast_possible_truncation))]
    #[must_use]
    pub fn len(&self) -> u32 {
        self.extends.len() as u32
    }

    /// Returns true if self has not `Extends`
    ///
    /// # Example
    /// ```
    /// use rhyoea::instance::information::ExtendsInformation;
    /// use rhyoea::extends::{Extends, Extensions};
    /// use rhyoea::result::InstanceError;
    ///
    /// let extensions = Extensions::available();
    /// let extensions_extends = ExtendsInformation::new(extensions)?;
    /// assert!(!extensions_extends.is_empty());
    ///
    /// # Ok::<(), InstanceError>(())
    /// ```
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}