kociemba 0.5.1

use crate::constants::*;
use crate::cubie::move_cubes;
use crate::cubie::{Corner::*, CubieCube, Edge::*};
use crate::error::Error;
use crate::{decode_table, write_table};

#[allow(non_camel_case_types)]
enum BS {
    ROT_URF3,
    ROT_F2,
    ROT_U4,
    MIRR_LR2,
}

/// 120° clockwise rotation around the long diagonal URF-DBL
const CC_ROT_URF3: CubieCube = CubieCube {
    cp: [URF, DFR, DLF, UFL, UBR, DRB, DBL, ULB],
    co: [1, 2, 1, 2, 2, 1, 2, 1],
    ep: [UF, FR, DF, FL, UB, BR, DB, BL, UR, DR, DL, UL],
    eo: [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1],
};

/// 180° rotation around the axis through the F and B centers
const CC_ROT_F2: CubieCube = CubieCube {
    cp: [DLF, DFR, DRB, DBL, UFL, URF, UBR, ULB],
    co: [0, 0, 0, 0, 0, 0, 0, 0],
    ep: [DL, DF, DR, DB, UL, UF, UR, UB, FL, FR, BR, BL],
    eo: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
};

/// 90° clockwise rotation around the axis through the U and D centers
const CC_ROT_U4: CubieCube = CubieCube {
    cp: [UBR, URF, UFL, ULB, DRB, DFR, DLF, DBL],
    co: [0, 0, 0, 0, 0, 0, 0, 0],
    ep: [UB, UR, UF, UL, DB, DR, DF, DL, BR, FR, FL, BL],
    eo: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
};

/// reflection at the plane through the U, D, F, B centers
const CC_MIRR_LR2: CubieCube = CubieCube {
    cp: [UFL, URF, UBR, ULB, DLF, DFR, DRB, DBL],
    co: [3, 3, 3, 3, 3, 3, 3, 3],
    ep: [UL, UF, UR, UB, DL, DF, DR, DB, FL, FR, BR, BL],
    eo: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
};

/// Tables to store symmetries.
#[derive(Debug, Clone)]
pub struct SymmetriesTables {
    pub bsc: [CubieCube; 4],
    pub sc: [CubieCube; 48],
    pub inv_idx: [u8; 48],
    pub mult_sym: Vec<usize>,
    pub conj_move: Vec<usize>,
    pub twist_conj: Vec<u16>,
    pub ud_edges_conj: Vec<u16>,
    pub flipslice_classidx: Vec<u16>,
    pub flipslice_sym: Vec<u8>,
    pub flipslice_rep: Vec<u32>,
    pub corner_classidx: Vec<u16>,
    pub corner_sym: Vec<u8>,
    pub corner_rep: Vec<u16>,
}

impl SymmetriesTables {
    pub fn new() -> Self {
        let flipslice = flipslice_syms().unwrap();
        let cornersyms = corner_syms().unwrap();
        Self {
            bsc: basicsc(),
            sc: sc(),
            inv_idx: inv_idx(),
            mult_sym: mult_sym(),
            conj_move: conj_move(),
            twist_conj: conj_twist().unwrap(),
            ud_edges_conj: conj_ud_edges().unwrap(),
            flipslice_classidx: flipslice.classidx,
            flipslice_sym: flipslice.sym,
            flipslice_rep: flipslice.rep,
            corner_classidx: cornersyms.classidx,
            corner_sym: cornersyms.sym,
            corner_rep: cornersyms.rep,
        }
    }
}

/// Permutations and orientation changes of the basic symmetries
fn basicsc() -> [CubieCube; 4] {
    let mut bsc = [CubieCube::default(); 4];
    bsc[BS::ROT_URF3 as usize] = CC_ROT_URF3.clone();
    bsc[BS::ROT_F2 as usize] = CC_ROT_F2.clone();
    bsc[BS::ROT_U4 as usize] = CC_ROT_U4.clone();
    bsc[BS::MIRR_LR2 as usize] = CC_MIRR_LR2.clone();
    bsc
}

/// Basic symmetries of the cube. All 48 cube symmetries can be generated by sequences of these 4 symmetries.
/// 
/// sc list, 48 CubieCubes will represent the 48 cube symmetries
pub fn sc() -> [CubieCube; 48] {
    let bsc = basicsc();
    let mut sc = [CubieCube::default(); 48];
    let mut cc = CubieCube::default(); // Identity cube
    let mut idx = 0;
    for _urf3 in 0..3 {
        for _f2 in 0..2 {
            for _u4 in 0..4 {
                for _lr2 in 0..2 {
                    sc[idx] = CubieCube {
                        cp: cc.cp,
                        co: cc.co,
                        ep: cc.ep,
                        eo: cc.eo,
                    };
                    idx += 1;
                    cc.multiply(bsc[BS::MIRR_LR2 as usize]);
                }
                cc.multiply(bsc[BS::ROT_U4 as usize]);
            }
            cc.multiply(bsc[BS::ROT_F2 as usize]);
        }
        cc.multiply(bsc[BS::ROT_URF3 as usize]);
    }
    sc
}

/// Fill the inv_idx array.
/// 
/// Indices for the inverse symmetries: sc[inv_idx[idx]] == sc[idx]^(-1)
pub fn inv_idx() -> [u8; 48] {
    let mut inv_idx_arr: [u8; 48] = [0; N_SYM];
    let sc = sc();
    for j in 0..N_SYM {
        for i in 0..N_SYM {
            let mut cc = CubieCube {
                cp: sc[j].cp,
                co: sc[j].co,
                ep: sc[j].ep,
                eo: sc[j].eo,
            };
            cc.corner_multiply(sc[i]);
            if cc.cp[URF as usize] == URF
                && cc.cp[UFL as usize] == UFL
                && cc.cp[ULB as usize] == ULB
            {
                inv_idx_arr[j] = i as u8;
                break;
            }
        }
    }
    inv_idx_arr
}

/// Generate the group table for the 48 cube symmetries.
fn mult_sym() -> Vec<usize> {
    let mut sym_mult = vec![0; N_SYM * N_SYM];
    let sc = sc();
    for i in 0..N_SYM {
        for j in 0..N_SYM {
            let mut cc = CubieCube {
                cp: sc[i].cp,
                co: sc[i].co,
                ep: sc[i].ep,
                eo: sc[i].eo,
            };
            cc.multiply(sc[j]);
            for k in 0..N_SYM {
                if cc == sc[k] {
                    // sc[i]*sc[j] == sc[k];
                    sym_mult[N_SYM * i + j] = k;
                    break;
                }
            }
        }
    }
    sym_mult
}

/// Generate the table for the conjugation of a move m by a symmetry s. conj_move[N_MOVE*s + m] = s*m*s^-1
fn conj_move() -> Vec<usize> {
    let sc = sc();
    let mc = move_cubes();
    let inv_idx = inv_idx();
    let mut move_conj = vec![0; N_MOVE * N_SYM];
    for s in 0..N_SYM {
        for m in ALL_MOVES {
            let mut ss = CubieCube {
                cp: sc[s].cp,
                co: sc[s].co,
                ep: sc[s].ep,
                eo: sc[s].eo,
            }; // copy cube
            ss.multiply(mc[m as usize]); // s*m
            ss.multiply(sc[inv_idx[s] as usize]); // s*m*s^-1
            for m2 in ALL_MOVES {
                if ss == mc[m2 as usize] {
                    move_conj[N_MOVE * s + m as usize] = m2 as usize;
                }
            }
        }
    }
    move_conj
}

/// Generate the phase 1 table for the conjugation of the twist t by a symmetry s. twist_conj[t, s] = s*t*s^-1 ####
fn conj_twist() -> Result<Vec<u16>, Error> {
    let sc = sc();
    let inv_idx = inv_idx();
    std::fs::create_dir_all("tables")?;
    let fname = "tables/conj_twist";
    let conj_table = std::fs::read(&fname).unwrap_or("".into());
    let mut twist_conj = vec![0; N_TWIST * N_SYM_D4H];
    if conj_table.is_empty() {
        println!("On the first run, several tables will be created. This may take a few minutes.");
        println!(
            "All tables are stored in tables/{}.\n\nCreating {} table...\n",
            fname, fname
        );
        for t in 0..N_TWIST {
            let mut cc = CubieCube::default();
            cc.set_twist(t as u16);
            for s in 0..N_SYM_D4H {
                let mut ss = CubieCube {
                    cp: sc[s].cp,
                    co: sc[s].co,
                    ep: sc[s].ep,
                    eo: sc[s].eo,
                }; // copy cube
                ss.corner_multiply(cc); // s*t
                ss.corner_multiply(sc[inv_idx[s] as usize]); // s*t*s^-1
                twist_conj[N_SYM_D4H * t + s] = ss.get_twist();
            }
        }
        write_table(fname, &twist_conj)?;
    } else {
        // println!("Loading {} table...", &fname);
        twist_conj = decode_table(&conj_table)?;
    }
    Ok(twist_conj)
}

/// Generate the phase 2 table for the conjugation of the URtoDB coordinate by a symmetrie.
fn conj_ud_edges() -> Result<Vec<u16>, Error> {
    let sc = sc();
    let inv_idx = inv_idx();
    std::fs::create_dir_all("tables")?;
    let fname = "tables/conj_ud_edges";
    let conj_table = std::fs::read(&fname).unwrap_or("".into());
    let mut ud_edges_conj = vec![0; N_UD_EDGES * N_SYM_D4H];
    if conj_table.is_empty() {
        println!("Creating {} table...", fname);
        for t in 0..N_UD_EDGES {
            if (t + 1) % 400 == 0 {
                print!("");
            }
            if (t + 1) % 32000 == 0 {
                println!();
            }
            let mut cc = CubieCube::default();
            cc.set_ud_edges(t);
            for s in 0..N_SYM_D4H {
                let mut ss = CubieCube {
                    cp: sc[s].cp,
                    co: sc[s].co,
                    ep: sc[s].ep,
                    eo: sc[s].eo,
                }; // copy cube
                ss.edge_multiply(cc); // s*t
                ss.edge_multiply(sc[inv_idx[s] as usize]); // s*t*s^-1
                ud_edges_conj[N_SYM_D4H * t + s] = ss.get_ud_edges();
            }
        }
        println!();
        write_table(fname, &ud_edges_conj)?;
    } else {
        // println!("Loading {} table...", &fname);
        ud_edges_conj = decode_table(&conj_table)?;
    }
    Ok(ud_edges_conj)
}

/// The tables to handle the symmetry reduced flip-slice coordinate in phase 1.
pub struct FlipSliceSyms {
    pub classidx: Vec<u16>,
    pub sym: Vec<u8>,
    pub rep: Vec<u32>,
}

/// Generate the tables to handle the symmetry reduced flip-slice coordinate in phase 1.
pub fn flipslice_syms() -> Result<FlipSliceSyms, Error> {
    let sc = sc();
    let inv_idx = inv_idx();
    std::fs::create_dir_all("tables")?;
    let fname1 = "tables/fs_classidx";
    let fname2 = "tables/fs_sym";
    let fname3 = "tables/fs_rep";
    let classidx_table = std::fs::read(&fname1).unwrap_or("".into());
    let sym_table = std::fs::read(&fname2).unwrap_or("".into());
    let rep_table = std::fs::read(&fname3).unwrap_or("".into());
    let mut flipslice_classidx = vec![65535; N_FLIP * N_SLICE]; // idx -> classidx
    let mut flipslice_sym = vec![0; N_FLIP * N_SLICE]; // idx -> symmetry
    let mut flipslice_rep = vec![0; N_FLIPSLICE_CLASS]; // classidx -> idx of representant
    if classidx_table.is_empty() {
        println!("Creating flipslice sym-tables...");
        let mut classidx = 0;
        let mut cc = CubieCube::default();
        for slc in 0..N_SLICE {
            cc.set_slice(slc as u16);
            for flip in 0..N_FLIP {
                cc.set_flip(flip as u16);
                let idx = N_FLIP * slc + flip;
                if (idx + 1) % 4000 == 0 {
                    print!(".");
                }
                if (idx + 1) % 320000 == 0 {
                    println!();
                }

                if flipslice_classidx[idx] == 65535 {
                    flipslice_classidx[idx] = classidx;
                    flipslice_sym[idx] = 0;
                    flipslice_rep[classidx as usize] = idx as u32;
                } else {
                    continue;
                }
                for s in 0..N_SYM_D4H {
                    // conjugate representant by all 16 symmetries
                    let si = inv_idx[s] as usize;
                    let mut ss = CubieCube {
                        cp: sc[si].cp,
                        co: sc[si].co,
                        ep: sc[si].ep,
                        eo: sc[si].eo,
                    }; // copy cube
                    ss.edge_multiply(cc);
                    ss.edge_multiply(sc[s]); // s^-1*cc*s
                    let idx_new = N_FLIP * ss.get_slice() as usize + ss.get_flip() as usize;
                    if flipslice_classidx[idx_new] == 65535 {
                        flipslice_classidx[idx_new] = classidx;
                        flipslice_sym[idx_new] = s as u8;
                    }
                }
                classidx += 1;
            }
        }
        println!();
        write_table(fname1, &flipslice_classidx)?;
        write_table(fname2, &flipslice_sym)?;
        write_table(fname3, &flipslice_rep)?;
    } else {
        // println!("Loading flipslice sym-tables...");
        flipslice_classidx = decode_table(&classidx_table)?;
        flipslice_sym = decode_table(&sym_table)?;
        flipslice_rep = decode_table(&rep_table)?;
    }
    Ok(FlipSliceSyms {
        classidx: flipslice_classidx,
        sym: flipslice_sym,
        rep: flipslice_rep,
    })
}


/// The tables to handle the symmetry reduced corner permutation coordinate in phase 2.
pub struct CornerSyms {
    pub classidx: Vec<u16>,
    pub sym: Vec<u8>,
    pub rep: Vec<u16>,
}

/// Generate the tables to handle the symmetry reduced corner permutation coordinate in phase 2.
pub fn corner_syms() -> Result<CornerSyms, Error> {
    let sc = sc();
    let inv_idx = inv_idx();
    std::fs::create_dir_all("tables")?;
    let fname1 = "tables/co_classidx";
    let fname2 = "tables/co_sym";
    let fname3 = "tables/co_rep";
    let classidx_table = std::fs::read(&fname1).unwrap_or("".into());
    let sym_table = std::fs::read(&fname2).unwrap_or("".into());
    let rep_table = std::fs::read(&fname3).unwrap_or("".into());
    let mut corner_classidx = vec![65535; N_CORNERS]; // idx -> classidx
    let mut corner_sym = vec![0; N_CORNERS]; // idx -> symmetry
    let mut corner_rep = vec![0; N_CORNERS_CLASS]; // classidx -> idx of representant
    if classidx_table.is_empty() {
        println!("Creating corner sym-tables...");
        let mut classidx = 0;
        let mut cc = CubieCube::default();
        for cp in 0..N_CORNERS {
            cc.set_corners(cp as u16);
            if (cp + 1) % 8000 == 0 {
                print!(".");
            }

            if corner_classidx[cp] == 65535 {
                corner_classidx[cp] = classidx;
                corner_sym[cp] = 0;
                corner_rep[classidx as usize] = cp as u16;
            } else {
                continue;
            }
            for s in 0..N_SYM_D4H {
                let si = inv_idx[s] as usize;
                // conjugate representant by all 16 symmetries
                let mut ss = CubieCube {
                    cp: sc[si].cp,
                    co: sc[si].co,
                    ep: sc[si].ep,
                    eo: sc[si].eo,
                }; // copy cube
                ss.corner_multiply(cc);
                ss.corner_multiply(sc[s]); // s^-1*cc*s
                let cp_new = ss.get_corners();
                if corner_classidx[cp_new as usize] == 65535 {
                    corner_classidx[cp_new as usize] = classidx;
                    corner_sym[cp_new as usize] = s as u8;
                }
            }
            classidx += 1;
        }
        println!();
        write_table(fname1, &corner_classidx)?;
        write_table(fname2, &corner_sym)?;
        write_table(fname3, &corner_rep)?;
    } else {
        // println!("Loading corner sym-tables...");
        corner_classidx = decode_table(&classidx_table)?;
        corner_sym = decode_table(&sym_table)?;
        corner_rep = decode_table(&rep_table)?;
    }
    Ok(CornerSyms {
        classidx: corner_classidx,
        sym: corner_sym,
        rep: corner_rep,
    })
}

#[cfg(test)]
mod test {
    use crate::symmetries::*;

    #[test]
    fn test_symcube() {
        let bsc = basicsc();
        let bsc2 = CubieCube {
            cp: [UBR, URF, UFL, ULB, DRB, DFR, DLF, DBL],
            co: [0, 0, 0, 0, 0, 0, 0, 0],
            ep: [UB, UR, UF, UL, DB, DR, DF, DL, BR, FR, FL, BL],
            eo: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
        };
        assert_eq!(bsc[2], bsc2);

        let sc = sc();
        let sc22 = CubieCube {
            cp: [DFR, DLF, UFL, URF, DRB, DBL, ULB, UBR],
            co: [2, 1, 2, 1, 1, 2, 1, 2],
            ep: [FR, DF, FL, UF, BR, DB, BL, UB, DR, DL, UL, UR],
            eo: [0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0],
        };

        assert_eq!(sc[22], sc22);
    }

    #[test]
    fn test_inv_idx() {
        let inv_idx = inv_idx();
        let inv_idx_py: [u8; 48] = [
            0, 1, 6, 3, 4, 5, 2, 7, 8, 9, 10, 15, 12, 13, 14, 11, 32, 41, 18, 19, 40, 33, 30, 31,
            44, 37, 26, 27, 36, 45, 22, 23, 16, 21, 46, 35, 28, 25, 38, 43, 20, 17, 42, 39, 24, 29,
            34, 47,
        ];

        assert_eq!(inv_idx, inv_idx_py);
    }

    #[test]
    fn test_mult_sym() {
        let mult_sym = mult_sym();
        assert_eq!(mult_sym[344], 11);
    }

    #[test]
    fn test_conj_move() {
        let conj_move = conj_move();
        assert_eq!(conj_move[863], 15);
    }

    #[test]
    fn test_conj_twist() {
        let conj_twist_table = conj_twist().unwrap();
        assert_eq!(conj_twist_table.len(), 34992);
        assert_eq!(conj_twist_table[34991], 1174);
        assert_eq!(conj_twist_table[349], 135);
        assert_eq!(conj_twist_table[34], 7);
        assert_eq!(conj_twist_table[3], 0);
    }

    #[test]
    fn test_conj_ud_edges() {
        let conj_ud_edges = conj_ud_edges().unwrap();
        assert_eq!(conj_ud_edges.len(), 645120);
        assert_eq!(conj_ud_edges[645119], 19857);
        assert_eq!(conj_ud_edges[64511], 29351);
        assert_eq!(conj_ud_edges[645], 31);
        assert_eq!(conj_ud_edges[0], 0);
    }

    #[test]
    fn test_flipslice_syms() {
        let flipslice_syms = flipslice_syms().unwrap();
        assert_eq!(flipslice_syms.classidx.len(), 1013760);
        assert_eq!(flipslice_syms.sym.len(), 1013760);
        assert_eq!(flipslice_syms.rep.len(), 64430);

        assert_eq!(flipslice_syms.classidx[12345], 2315);
        assert_eq!(flipslice_syms.sym[12345], 6);
        assert_eq!(flipslice_syms.rep[12345], 42257);
    }

    #[test]
    fn test_corner_syms() {
        let cornersyms = corner_syms().unwrap();
        assert_eq!(cornersyms.classidx.len(), 40320);
        assert_eq!(cornersyms.sym.len(), 40320);
        assert_eq!(cornersyms.rep.len(), 2768);

        assert_eq!(cornersyms.classidx[12345], 1831);
        assert_eq!(cornersyms.sym[12345], 8);
        assert_eq!(cornersyms.rep[1234], 2335);
    }
}