
module Main where

import Arithmetic
import Trit
import Converter
import System.IO.Unsafe
import Data.Ratio
import Utilities
import Thread

main = startM1

startM1 :: IO()
startM1 = do
          c <- unsafeInterleaveIO (mult (rationalToGray (1%3)) (rationalToGray (0%1)))
          putStrLn (show  (take 100 (drop 1 c)))




mult :: Gray -> Gray -> IO Gray
mult xs ys = do
                                        c <- threadTesting1 xs ys
                                        case c of

                                           101 -> do
                                                   --putStrLn ("In case 101")
                                                   let tx = drop 2 xs
                                                   let ty = drop 2 ys
                                                   t1 <- unsafeInterleaveIO (addition tx ty)
                                                   t2 <- unsafeInterleaveIO (addition (fl t1) (1:t1))
                                                   t3 <- unsafeInterleaveIO (mult tx ty)
                                                   c' <- unsafeInterleaveIO (addition t2 (1:0:0:(fl t3)))
                                                   return c'

                                           102 -> do
                                                   --putStrLn ("In case 102")
                                                   let tx = drop 2 xs
                                                   let ty = drop 2 ys
                                                   t1 <- unsafeInterleaveIO (addition (fl tx) ty)
                                                   t2 <- unsafeInterleaveIO (addition tx ty)
                                                   t0 <- unsafeInterleaveIO (addition t1 (1:fl t2))
                                                   t3 <- unsafeInterleaveIO (mult tx ty)
                                                   c' <- unsafeInterleaveIO (addition t0 (1:1:0:fl t3))
                                                   return c'

                                           103 -> do
                                                   --putStrLn ("In case 103")
                                                   let tx = drop 2 xs
                                                   let ty = drop 2 ys
                                                   t <- unsafeInterleaveIO (mult (0:0:tx) (0:0:ty))
                                                   return (fl t)

                                           104 -> do
                                                   --putStrLn ("In case 104")
                                                   let tx = drop 2 xs
                                                   let ty = drop 2 ys
                                                   t <- unsafeInterleaveIO (mult (0:0:tx) (0:1:ty))
                                                   return (fl t)

                                           201 -> do
                                                   c' <- unsafeInterleaveIO (mult ys xs)
                                                   return c'

                                           202 -> do
                                                   --putStrLn ("In case 202")
                                                   let tx = drop 2 xs
                                                   let ty = drop 2 ys
                                                   t1 <- unsafeInterleaveIO (addition tx ty)
                                                   t2 <- unsafeInterleaveIO (addition t1 (0:fl t1))
                                                   t3 <- unsafeInterleaveIO (mult tx ty)
                                                   c' <- unsafeInterleaveIO (addition t2 (1:1:1:fl t3))
                                                   return c'

                                           203 -> do
                                                   --putStrLn ("In case 203")
                                                   let tx = drop 2 xs
                                                   let ty = drop 2 ys
                                                   t <- unsafeInterleaveIO (mult (0:1:tx) (0:0:ty))
                                                   return (fl t)

                                           204 -> do
                                                   --putStrLn ("In case 204")
                                                   let tx = drop 2 xs
                                                   let ty = drop 2 ys
                                                   t <- unsafeInterleaveIO (mult (0:1:tx) (0:1:ty))
                                                   return (fl t)

                                           30 ->  do
                                                   --putStrLn ("In case 30")
                                                   let y1 = ys !! 0
                                                   let tx = drop 2 xs
                                                   let ty = drop 3 ys
                                                   t1 <- unsafeInterleaveIO (addition ((f0' y1):1:ty) ((f0' y1):1:0:ty))
                                                   t0 <- unsafeInterleaveIO (mult tx (y1: fl ty))
                                                   let c4 = head t0
                                                   let d4 = fl (tail t0)
                                                   c' <- unsafeInterleaveIO (addition t1 (c4:1:0:0:d4))
                                                   return c'

                                           31 -> do
                                                  --putStrLn ("In case 31")
                                                  let tx = drop 2 xs
                                                  c' <- unsafeInterleaveIO (mult (0:0:tx) ys)
                                                  return (fl c')

                                           40 ->  do
                                                   --putStrLn ("In case 40")
                                                   let tx = drop 2 xs
                                                   let y2 = ys !! 1
                                                   let ty = drop 3 ys
                                                   t1 <- unsafeInterleaveIO (addition (y2:fl ty) tx)
                                                   t2 <- unsafeInterleaveIO (addition (fl t1) (1:y2:1:ty))
                                                   t0 <- unsafeInterleaveIO (mult tx (y2:fl ty))
                                                   let c2 = f0' (head t0)
                                                   let d2 = fl (tail t0)
                                                   c' <- unsafeInterleaveIO (addition t2 (1:c2:1:0:d2))
                                                   return c'

                                           41 ->  do
                                                   --putStrLn ("In case 41")
                                                   let tx = drop 2 xs
                                                   let y2 = ys !! 1
                                                   let ty = drop 3 ys
                                                   c' <- unsafeInterleaveIO (mult (0:0:tx) (0:y2:1:ty))
                                                   return (fl c')

                                           50 ->  do
                                                   --putStrLn ("In case 50")
                                                   let tx = drop 2 xs
                                                   let y2 = ys !! 1
                                                   let ty = drop 3 ys
                                                   t1 <- unsafeInterleaveIO (addition tx (fl (y2:fl ty)))
                                                   t2 <- unsafeInterleaveIO (addition t1 (0:y2:1:ty))
                                                   t0 <- unsafeInterleaveIO (mult (fl tx) (y2:fl ty))
                                                   let c1 = f0' (head t0)
                                                   let d1 = fl (tail t0)
                                                   c' <- unsafeInterleaveIO (addition t2 (1:c1:1:0:d1))
                                                   return c'

                                           51 ->  do
                                                   --putStrLn ("In case 51")
                                                   let tx = drop 2 xs
                                                   let y2 = ys !! 1
                                                   let ty = drop 3 ys
                                                   c' <- unsafeInterleaveIO (mult (0:1:tx) (0:y2:1:ty))
                                                   return (fl c')


                                           60 ->  do
                                                   --putStrLn ("In case 60")
                                                   let tx = drop 2 xs
                                                   let y1 = ys !! 0
                                                   let ty = drop 3 ys
                                                   t1 <- unsafeInterleaveIO (addition ((f0' y1):1:ty) (y1:1:0:ty))
                                                   t0 <- unsafeInterleaveIO (mult (fl tx) (y1:fl ty))
                                                   let c1 = head t0
                                                   let d1 = fl (tail t0)
                                                   c' <- unsafeInterleaveIO (addition t1 (c1:1:0:0:d1))
                                                   return c'

                                           61 ->  do
                                                   --putStrLn ("In case 61")
                                                   let tx = drop 2 xs
                                                   let y1 = ys !! 0
                                                   let ty = drop 3 ys
                                                   c' <- unsafeInterleaveIO (mult (0:1:tx) (y1:1:0:ty))
                                                   return (fl c')


                                           70 ->  do
                                                   --putStrLn ("In case 70")
                                                   c' <- unsafeInterleaveIO (mult ys xs)
                                                   return c'

                                           80 ->  do
                                                   --putStrLn ("In case 80")
                                                   let x2 = xs !! 1
                                                   let y2 = ys !! 1
                                                   let tx = drop 3 xs
                                                   let ty = drop 3 ys
                                                   t1 <- unsafeInterleaveIO (addition (x2:fl tx) (y2:fl ty))
                                                   t0 <- unsafeInterleaveIO (mult (x2:fl tx) (y2:fl ty))
                                                   let c1 = head (fl t1)
                                                   let d1 = tail (fl t1)
                                                   let c2 = f0' (head t0)
                                                   let d2 = fl (tail t0)
                                                   c' <- unsafeInterleaveIO (addition (c1:1:(fl d1)) (1:c2:1:0:d2))
                                                   return c'

                                           81 ->  do
                                                   --putStrLn ("In case 81")
                                                   let x2 = xs !! 1
                                                   let y2 = ys !! 1
                                                   let tx = drop 3 xs
                                                   let ty = drop 3 ys
                                                   c' <- unsafeInterleaveIO (mult (0:x2:1:tx) (0:y2:1:ty))
                                                   return (fl c')

                                           90 ->  do
                                                   --putStrLn ("In case 90")
                                                   let x2 = xs!!1
                                                   let y1 = ys!!0
                                                   let tx = drop 3 xs
                                                   let ty = drop 3 ys
                                                   t0 <- unsafeInterleaveIO (mult (x2:fl tx) (y1:fl ty))
                                                   let c1 = head t0
                                                   let d1 = fl (tail t0)
                                                   c' <- unsafeInterleaveIO (addition ((f0' y1):1:0:ty) (c1:1:0:0:d1))
                                                   return c'

                                           91 ->  do
                                                   --putStrLn ("In case 91")
                                                   let x2 = xs!!1
                                                   let y1 = ys!!0
                                                   let tx = drop 3 xs
                                                   let ty = drop 3 ys
                                                   c' <- unsafeInterleaveIO (mult (0:x2:1:tx) (y1:1:0:ty))
                                                   return (fl c')

                                           100 -> do
                                                  --putStrLn ("In case 100")
                                                  let x1 = head xs
                                                  let y1 = head ys
                                                  let tx = drop 3 xs
                                                  let ty = drop 3 ys
                                                  t0 <- unsafeInterleaveIO (mult (x1:fl tx) (y1:fl ty))
                                                  let c4 = head t0
                                                  let d4 = fl (tail t0)
                                                  return (c4:1:0:0:0:d4)



f0' 0 = 1
f0' 1 = 0

