import Data.List

-- Оголошуємо тип Колір, який може приймати одне з перелічених значень і який можна порівнювати
data Color = Red | Orange | Yellow | Green | Blue | Violet deriving Eq

-- Тип Поворот, приймає одне з перечислених значень
data Turn = Forward | Backward | Clockwise | Counterclockwise | ToRight | ToLeft

-- Куб — складний тип, складається з шести Кольорів.
-- Виглядає як сішна структура, використовується схожим чином,
-- за винятком того, що містить не поля, а функції, які приймають Куб 
-- і повертають колір відповідної сторони
data Cube = Cube{front 
                ,back  
                ,left  
                ,right 
                ,up    
                ,down  :: Color
                } deriving Eq



-- Функція, застосовує до Куба cube Поворот turn 
-- Точніше, повертає новий куб, повернутий відносно старого. Підміни ніхто не помітить :)  
rotate :: Turn -> Cube -> Cube
rotate turn cube = case turn of
                        -- читати так: якщо turn == Forward, то повернути (з функції) куб, у якого передня грань така ж, 
                        -- як верхня у старого куба, задня така ж, як нижня у старого і т. д.
                        Forward          -> Cube{front = up cube,    back = down cube,  left = left cube,  right = right cube, up = back cube,  down = front cube}
                        Backward         -> Cube{front = down cube,  back = up cube,    left = left cube,  right = right cube, up = front cube, down = back cube}
                        Clockwise        -> Cube{front = front cube, back = back cube,  left = down cube,  right = up cube,    up = left cube,  down = right cube}
                        Counterclockwise -> Cube{front = front cube, back = back cube,  left = up cube,    right = down cube,  up = right cube, down = left cube}
                        ToRight          -> Cube{front = left cube,  back = right cube, left = back cube,  right = front cube, up = up cube,    down = down cube}
                        ToLeft           -> Cube{front = right cube, back = left cube,  left = front cube, right = back cube,  up = up cube,    down = down cube}



-- Деякі варіанти можна звести до одного й того ж за допомогою обертання.
-- Назвемо «канонічною» таку орієнтацію, при якій передня грань червона, 
-- а оранжева грань знаходиться справа або ззаду, причому якщо вона ззаду,
-- то справа знаходиться жовта. До такої орієнтації можна звести будь-яку іншу.
rotateToCanonical :: Cube -> Cube
-- Точкою позначається композиція функцій : зробити orangeOrYellowToRight з результатом виконання redToFront
-- ці дві функції оголошені тут же, трохи нижче
rotateToCanonical cube = (orangeOrYellowToRight . redToFront) cube
                         where
                            -- Якщо передня грань червона, то повертаємо куб так як є, нічого не крутимо
                            -- Якщо ж червона задня грань, то повертаємо направо і ще раз повертаємо направо
                            -- В rotate ToRight присутні не всі аргументи, але помилки немає, тому що
                            -- rotate ToRight повертає функцію, яка приймає куб і повертає куб.
                            redToFront c | (front c == Red) = c
                                         | (back c  == Red) = (rotate ToRight . rotate ToRight) c
                                         | (left c  == Red) = rotate ToRight c
                                         | (right c == Red) = rotate ToLeft c
                                         | (up c    == Red) = rotate Forward c
                                         | (down c  == Red) = rotate Backward c

                            orangeOrYellowToRight c | (back c  == Orange) = yellowToRight c
                                                    | (left c  == Orange) = (rotate Clockwise . rotate Clockwise) c
                                                    | (right c == Orange) = c
                                                    | (up c    == Orange) = rotate Clockwise c
                                                    | (down c  == Orange) = rotate Counterclockwise c
                                                    where yellowToRight c1 | (right c1 == Yellow) = c1
                                                                           | (left c1  == Yellow) = (rotate Clockwise . rotate Clockwise) c1
                                                                           | (up c1    == Yellow) = rotate Clockwise c1
                                                                           | (down c1  == Yellow) = rotate Counterclockwise c1



-- Ця функція приймає список списків в кожному з яких по шість кольорів,
-- і перетворює кожен із цих списків на куб
-- map — це функція відображення, вона приймає функцію і список 
-- і застосовує функцію до кожного елемента списку
colorsToCubes :: [[color]] -> [Cube]
colorsToCubes l = map f l
                  where 
                    f l1 = Cube{front = l1 !! 0, back = l1 !! 1, left = l1 !! 2, right = l1 !! 3, up = l1 !! 4, down = l1 !! 5}



-- Ця функція видаляє куби, які повторюються 
removeDuplicate :: [Cube] -> [Cube]
removeDuplicate list =  nub [rotateToCanonical cube | cube <- list]


-- Всі перестановки списку з усіх кольорів
perm = permutations([Red, Orange, Yellow, Green, Blue, Violet])



main = print $ (length . removeDuplicate . colorsToCubes) perm