//!
//! Constructors for struct Network.
//!

use super::Network;

use rand::prelude::*;

impl Network {
    /// Create square lattice.
    pub fn make_square_lattice(length: u32) -> Network {
        let n = length * length;
        let mut edge_list = Vec::new();

        for i in 0..n {
            let first = i;
            let second = (i / length) * length + (i + 1) % length;
            let third = (i + length) % n;
            edge_list.push((first, second));
            edge_list.push((first, third));
        }

        Network { n, edge_list }
    }

    /// Create regular lattice
    pub fn make_regular_lattice(dim: u32, length: u32) -> Network {
        let n = length.pow(dim);
        let mut edge_list = Vec::new();

        // index = x_0 + x_1 L + x_2 L^2 + ... + x_(d-1) L^(d-1) for regular lattice
        // Lattice point is expressed as (x_0, x_1, ... x_(d-1))
        let mut x = vec![0u32; dim as usize];

        for index in 0..n {
            // Get x = [x_0, x_1, ... ,  x_(d-1)]
            let mut buff = index;
            for i in 0..dim {
                x[(dim - 1 - i) as usize] = buff / length.pow(dim - 1 - i);
                buff = index % length.pow(dim - 1 - i);
            }

            // Make edge_list : each index has 2d links
            for i in 0..dim {
                let first = index;
                let mut second = 0;
                for j in 0..dim {
                    if i != j {
                        second += x[j as usize] * length.pow(j);
                    } else {
                        second += ((x[j as usize] + 1) % length) * length.pow(j);
                    }
                }
                edge_list.push((first, second));
            }
        }

        Network { n, edge_list }
    }

    /// create regular random graph
    pub fn make_regular_random_graph(n: u32, frac: f64, rng: &mut StdRng) -> Network {
        let mut edge_list = Vec::<(u32, u32)>::new();

        // First  : Create edge list of perfect graph
        // Second : Choose frac * n_e links
        let mut perfect_list = Vec::<(u32, u32)>::new();
        for i in 0..(n - 1) {
            for j in (i + 1)..n {
                perfect_list.push((i, j));
            }
        }
        let n_e = n * (n - 1) / 2;

        let e = (frac * n_e as f64).round() as u32;

        for i in 0..e {
            let index = rng.gen::<u32>() % (n_e - i);
            let choosed = perfect_list[(i + index) as usize];
            edge_list.push(choosed);
            perfect_list[(i + index) as usize] = perfect_list[i as usize];
            perfect_list[i as usize] = choosed;
        }

        Network { n, edge_list }
    }

    /// Check of the self loop
    /// Calculation time is O(L).
    pub fn exist_self_loop(&self) -> bool {
        let length = self.edge_list.len();
        for i in 0..length {
            if self.edge_list[i].0 == self.edge_list[i].1 {
                return true;
            }
        }
        false
    }

    /// Check of the multi loop
    /// Caution : Calculation time is O(L^2), it can be vast time. Be careful.
    pub fn exist_multi_loop(&self) -> bool {
        let mut target = self.clone();
        target.make_acsending_order();
        let length = target.edge_list.len();

        for i in 0..length {
            let speciman = target.edge_list[i];
            for j in (i + 1)..length {
                let target = target.edge_list[j];
                if target == speciman {
                    return true;
                }
            }
        }

        false
    }

    /// Make edge (v1, v2) be v1 <= v2
    /// This procedure is not elemental for edge_list, but sometimes useful.
    fn make_acsending_order(&mut self) {
        for i in 0..self.edge_list.len() {
            if self.edge_list[i].0 > self.edge_list[i].1 {
                let temp = self.edge_list[i].0;
                self.edge_list[i].0 = self.edge_list[i].1;
                self.edge_list[i].1 = temp;
            }
        }
    }

    pub fn show_network(&self) {
        println!("n = {}", self.n);
        for i in 0..self.edge_list.len() {
            println!(
                "edge_list[{}] = ({},{})",
                i, self.edge_list[i].0, self.edge_list[i].1
            );
        }
    }
}

#[test]
fn test_self_multi() {
    let target1 = Network::make_square_lattice(2);
    let target2 = Network::make_square_lattice(3);

    let n = 3;
    let edge_list = vec![(0, 1), (1, 1), (1, 2)];
    let target3 = Network { n, edge_list };

    assert_eq!(target1.exist_multi_loop(), true);
    assert_eq!(target2.exist_multi_loop(), false);
    assert_eq!(target3.exist_multi_loop(), false);

    assert_eq!(target1.exist_self_loop(), false);
    assert_eq!(target2.exist_self_loop(), false);
    assert_eq!(target3.exist_self_loop(), true);
}

/// Check of the RRG is difficult, so we do the self loop check and multi loop check.N
#[test]
fn test_make_regular_random_graph() {
    let mut rng: StdRng = SeedableRng::seed_from_u64(100u64);
    let n = 100u32;
    let frac = 0.5;

    let target = Network::make_regular_random_graph(n, frac, &mut rng);

    assert_eq!(target.exist_multi_loop(), false);
    assert_eq!(target.exist_self_loop(), false);
    assert_eq!(target.get_n(), 100u32);
    assert_eq!(target.get_edge_list().len(), 25 * 99);
}