// Copyright (c) 2017 The Noise-rs Developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT
// or http://opensource.org/licenses/MIT>, at your option. All files in the
// project carrying such notice may not be copied, modified, or distributed
// except according to those terms.

use {GenFn2, GenFn3, GenFn4};

use {PermutationTable, math};
use {Point2, Point3, Point4};
use num_traits::Float;

/// A callable struct for applying 2-dimensional [fractional Brownian motion]
/// (http://en.wikipedia.org/wiki/Fractional_Brownian_motion).
///
/// Fractional Brownian motion is a way of combining multiple octaves of a noise
/// function to create a richer and more varied output. It can theoretically be
/// used with any noise function, but it tends to only produce good results with
/// gradient noise functions.
///
/// The struct contains many parameters, which can either be set using the
/// builder methods provided, or by constructing the type manually.
///
/// # Example
///
/// ```rust
/// extern crate noise;
/// extern crate rand;
///
/// use noise::{Brownian2, perlin2};
///
/// # fn main() {
/// let seed = rand::random();
/// let noise = Brownian2::new(perlin2, 4).wavelength(32.0);
/// let val = noise.apply(&seed, &[42.0, 37.0]);
/// # }
/// ```
#[derive(Copy, Clone)]
#[deprecated(since="0.3.0", note="please use `Fbm::new()` instead")]
pub struct Brownian2<T, F: GenFn2<T>> {
    /// The underlying noise function to call.
    pub function: F,
    /// The number of times to call the noise function.
    pub octaves: usize,
    /// The base frequency of the noise
    pub frequency: T,
    /// The rate at which the amplitude of the noise is reduced for each octave.
    pub persistence: T,
    /// The rate at which the frequency of the noise increases for each octave.
    pub lacunarity: T,
}

/// A callable struct for applying 3-dimensional [fractional Brownian motion]
/// (http://en.wikipedia.org/wiki/Fractional_Brownian_motion).
///
/// Fractional Brownian motion is a way of combining multiple octaves of a noise
/// function to create a richer and more varied output. It can theoretically be
/// used with any noise function, but it tends to only produce good results with
/// gradient noise functions.
///
/// The struct contains many parameters, which can either be set using the
/// builder methods provided, or by constructing the type manually.
///
/// # Example
///
/// ```rust
/// extern crate noise;
/// extern crate rand;
///
/// use noise::{Brownian3, perlin3};
///
/// # fn main() {
/// let seed = rand::random();
/// let noise = Brownian3::new(perlin3, 4).wavelength(32.0);
/// let val = noise.apply(&seed, &[42.0, 37.0, 2.0]);
/// # }
/// ```
#[derive(Copy, Clone)]
#[deprecated(since="0.3.0", note="please use `Fbm::new()` instead")]
pub struct Brownian3<T, F: GenFn3<T>> {
    /// The underlying noise function to call.
    pub function: F,
    /// The number of times to call the noise function.
    pub octaves: usize,
    /// The base frequency of the noise
    pub frequency: T,
    /// The rate at which the amplitude of the noise is reduced for each octave.
    pub persistence: T,
    /// The rate at which the frequency of the noise increases for each octave.
    pub lacunarity: T,
}

/// A callable struct for applying 4-dimensional [fractional Brownian motion]
/// (http://en.wikipedia.org/wiki/Fractional_Brownian_motion).
///
/// Fractional Brownian motion is a way of combining multiple octaves of a noise
/// function to create a richer and more varied output. It can theoretically be
/// used with any noise function, but it tends to only produce good results with
/// gradient noise functions.
///
/// The struct contains many parameters, which can either be set using the
/// builder methods provided, or by constructing the type manually.
///
/// # Example
///
/// ```rust
/// extern crate noise;
/// extern crate rand;
///
/// use noise::{Brownian4, perlin4};
///
/// # fn main() {
/// let seed = rand::random();
/// let noise = Brownian4::new(perlin4, 4).wavelength(32.0);
/// let val = noise.apply(&seed, &[42.0, 37.0, 2.0, 3.0]);
/// # }
/// ```
#[derive(Copy, Clone)]
#[deprecated(since="0.3.0", note="please use `Fbm::new()` instead")]
pub struct Brownian4<T, F: GenFn4<T>> {
    /// The underlying noise function to call on each octave.
    pub function: F,
    /// The number of times to call the noise function.
    pub octaves: usize,
    /// The base frequency of the noise
    pub frequency: T,
    /// The rate at which the amplitude of the noise is reduced on each octave.
    pub persistence: T,
    /// The rate at which the frequency of the noise increases on each octave.
    pub lacunarity: T,
}

macro_rules! impl_brownian {
    { $Brownian:ident, $GenFn:ident, $Point:ident, $mapn:path } => {
        impl<T: Float, F: $GenFn<T>> $Brownian<T, F> {
            /// Constructs a new brownian noise function, defaulting to:
            ///
            /// - frequency: `1.0`
            /// - lacunarity: `2.0`
            /// - persistence: `0.5`
            #[inline]
            #[deprecated(since="0.3.0", note="please use `noisemodule::Fbm` instead")]
            pub fn new(function: F, octaves: usize) -> $Brownian<T, F> {
                $Brownian {
                    function: function,
                    octaves: octaves,
                    frequency: math::cast(1.0f32),
                    lacunarity: math::cast(2.0f32),
                    persistence: math::cast(0.5f32),
                }
            }

            /// A builder method that sets underlying noise function to call on
            /// each octave.
            #[inline]
            pub fn function<Q: $GenFn<T>>(self, function: Q) -> $Brownian<T, Q> {
                let $Brownian { octaves, frequency, lacunarity, persistence, .. } = self;
                $Brownian {
                    function: function,
                    octaves: octaves,
                    frequency: frequency,
                    persistence: persistence,
                    lacunarity: lacunarity,
                }
            }

            /// A builder method that sets the number of times to call the noise
            /// function.
            #[inline]
            pub fn octaves(self, octaves: usize) -> $Brownian<T, F> {
                $Brownian { octaves: octaves, ..self }
            }

            /// A builder method that sets the wavelength of the brownian noise.
            /// This is equivalent to `self.frequency(wavelength.recip())`.
            #[inline]
            pub fn wavelength(self, wavelength: T) -> $Brownian<T, F> {
                self.frequency(wavelength.recip())
            }

            /// A builder method that sets the base frequency of the noise.
            #[inline]
            pub fn frequency(self, frequency: T) -> $Brownian<T, F> {
                $Brownian { frequency: frequency, ..self }
            }

            /// A builder method that sets the rate at which the amplitude of
            /// the noise is reduced on each octave.
            #[inline]
            pub fn persistence(self, persistence: T) -> $Brownian<T, F> {
                $Brownian { persistence: persistence, ..self }
            }

            /// A builder method that sets the rate at which the frequency of
            /// the noise increases on each octave.
            #[inline]
            pub fn lacunarity(self, lacunarity: T) -> $Brownian<T, F> {
                $Brownian { lacunarity: lacunarity, ..self }
            }

            /// Apply the Brownian noise function for the supplied permutation table and point.
            #[inline]
            pub fn apply(&self, perm_table: &PermutationTable, point: &$Point<T>) -> T {
                // Fixes weird accumulation at the origin.
                //
                // The chosen offset is the square root of 3. An irrational
                // number is chosen so grid-aligned noise values don't coincide
                // with each other.
                const OFFSET: f64 = 1.73205080756887;

                let mut frequency: T = self.frequency;
                let mut amplitude: T = math::cast(1);
                let mut total_amplitude = T::zero();
                let mut result: T = math::cast(0);
                let mut offset: T = math::cast(OFFSET);
                let point = *point;
                for _ in 0..self.octaves {
                    let scaled_point = $mapn(point, |v| v * frequency + offset);
                    result = result + ((self.function)(perm_table, &scaled_point) * amplitude);
                    total_amplitude = total_amplitude + amplitude;
                    amplitude = amplitude * self.persistence;
                    frequency = frequency * self.lacunarity;
                    offset = offset + math::cast(OFFSET);
                }
                result / total_amplitude
            }
        }
    }
}

impl_brownian! { Brownian2, GenFn2, Point2, math::map2 }
impl_brownian! { Brownian3, GenFn3, Point3, math::map3 }
impl_brownian! { Brownian4, GenFn4, Point4, math::map4 }

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> Fn(&'a PermutationTable, &'b Point2<T>) for Brownian2<T, F>
    where T: Float,
          F: GenFn2<T>,
{
    /// Applies the brownian noise function for the supplied permutation table and point.
    extern "rust-call" fn call(&self,
                               (perm_table, point): (&'a PermutationTable, &'b Point2<T>))
                               -> T {
        self.apply(perm_table, point)
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> FnMut(&'a PermutationTable, &'b Point2<T>) for Brownian2<T, F>
    where T: Float,
          F: GenFn2<T>,
{
    extern "rust-call" fn call_mut(&mut self, (table, point): (&'a Seed, &'b Point2<T>)) -> T {
        self.call((table, point))
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> FnOnce(&'a Seed, &'b Point2<T>) for Brownian2<T, F>
    where T: Float,
          F: GenFn2<T>,
{
    type Output = T;
    extern "rust-call" fn call_once(self, (seed, point): (&'a Seed, &'b Point2<T>)) -> T {
        self.call((seed, point))
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> Fn(&'a Seed, &'b Point3<T>) for Brownian3<T, F>
    where T: Float,
          F: GenFn3<T>,
{
    /// Applies the brownian noise function for the supplied seed and point.
    extern "rust-call" fn call(&self, (seed, point): (&'a Seed, &'b Point3<T>)) -> T {
        self.apply(seed, point)
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> FnMut(&'a Seed, &'b Point3<T>) for Brownian3<T, F>
    where T: Float,
          F: GenFn3<T>,
{
    extern "rust-call" fn call_mut(&mut self, (seed, point): (&'a Seed, &'b Point3<T>)) -> T {
        self.call((seed, point))
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> FnOnce(&'a Seed, &'b Point3<T>) for Brownian3<T, F>
    where T: Float,
          F: GenFn3<T>,
{
    type Output = T;
    extern "rust-call" fn call_once(self, (seed, point): (&'a Seed, &'b Point3<T>)) -> T {
        self.call((seed, point))
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> Fn(&'a Seed, &'b ::Point4<T>) for Brownian4<T, F>
    where T: Float,
          F: GenFn4<T>,
{
    /// Applies the brownian noise function for the supplied seed and point.
    extern "rust-call" fn call(&self, (seed, point): (&'a Seed, &'b Point4<T>)) -> T {
        self.apply(seed, point)
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> FnMut(&'a Seed, &'b Point4<T>) for Brownian4<T, F>
    where T: Float,
          F: GenFn4<T>,
{
    extern "rust-call" fn call_mut(&mut self, (seed, point): (&'a Seed, &'b Point4<T>)) -> T {
        self.call((seed, point))
    }
}

#[cfg(rust_unstable)]
impl<'a, 'b, T, F> FnOnce(&'a Seed, &'b Point4<T>) for Brownian4<T, F>
    where T: Float,
          F: GenFn4<T>,
{
    type Output = T;
    extern "rust-call" fn call_once(self, (seed, point): (&'a Seed, &'b Point4<T>)) -> T {
        self.call((seed, point))
    }
}