module Exercise_8 where

import Game
import System.Random

{- Library DO NOT CHANGE -}
data Tree a =
  Empty |
  Node a (Tree a) (Tree a)
    deriving (Show, Eq)

insert :: Ord a => a -> Tree a -> Tree a
insert x Empty = Node x Empty Empty
insert x (Node a l r)
  | x < a = Node a (insert x l) r
  | x > a = Node a l (insert x r)
  | otherwise = Node a l r

delete :: Ord a => a -> Tree a -> Tree a
delete _ Empty = Empty
delete x (Node a l r)
  | x == a     =  combine l r
  | x < a      =  Node a (delete x l) r
  | otherwise  =  Node a l (delete x r)

find :: Ord a => a -> Tree a -> Bool
find _ Empty  =  False
find x (Node a l r)
  | x == a     =  True
  | x < a      =  find x l
  | otherwise  =  find x r

combine :: Tree a -> Tree a -> Tree a
combine Empty r  =  r
combine l Empty  =  l
combine l r      =  Node m l r'  where (m,r') = delL r

delL :: Tree a -> (a, Tree a)
delL (Node a Empty r)  = (a, r)
delL (Node a l     r)  = (m, Node a l' r)  where (m,l') = delL l
{- End Library -}


{-H8.1-}

prettyTree :: Show a => Tree a -> String
prettyTree = undefined

{-H8.2-}

{- Library DO NOT CHANGE -}
data Traversal = Inorder | Preorder | Postorder
  deriving (Show, Eq)
{- End Library -}

treeToList :: Traversal -> Tree a -> [a]
treeToList = undefined

{-H8.3-}

modify :: Ord a => (Maybe b -> Maybe b) -> a -> Tree (a,b) -> Tree (a,b)
modify = undefined

{- insert, update und delete müssen in der Vorlage "Exercise_8_Tree.hs"
 - implementiert werden! Das Ändern der markierten Teile in der Vorlage
 - wird als Betrugsversucht gewertet. -}


{-H8.4-}

{-
  Relevanter Auszug aus Game.hs:
    type Position   = (Int, Int)
    data Player     = Red | Blue deriving (Eq, Ord, Show, Read)
    data Board      = …
    
  Folgende Hilfsfunktionen könnten interessant sein:
    isValidPosition :: Position -> Bool
    neighbors :: Position -> [Position]
    isNeighborOf :: Position -> Position -> Bool
    playerAt :: Position -> Board -> Maybe Player
    isValidMove :: Position -> Board -> Bool
    
  Für mehr Hilfsfunktionen und detailliertere Dokumentation siehe <http://www21.in.tum.de/teaching/info2/WS1415/game/>
-}

{-WETT-}

nextMove :: Player -> Board -> Position
nextMove = undefined

-- ---------------------------------------------------------------------------------------------------------------------
--  Ignorieren Sie alles ab hier, falls Sie nicht am Wettbewerb teilnehmen möchten.
-- ---------------------------------------------------------------------------------------------------------------------

-- Wenn Sie das erweiterte Interface (mit Zufallsgenerator und Zustand) nutzen möchten, ersetzen Sie das "True" hier 
-- durch "False"...
useSimpleStrategy :: Bool
useSimpleStrategy = True

-- ...und implementieren Sie hier Ihre Strategie. Sie dürfen aber auf KEINEN FALL die obige Definition von 
-- "nextMove" löschen. Setzen Sie in diesem Fall einfach "nextMove" auf "undefined", wie in der Schablone vorgegeben.
-- Das System wählt anhand des Werts von "useSimpleStrategy" die Tests aus.

-- Dies ist der Typ des Zustands, den Sie in Ihrer Strategie mitführen. Sie können ihn frei wählen.
type MyState = Int

-- Dies ist der Anfangszustand Ihrer Strategie, abhängig vom Zufallsgenerator g (siehe Dokumentation von System.Random) 
-- und dem Spieler, als der Sie spielen (Red oder Blue)
myInitialState :: RandomGen g => g -> Player -> MyState
myInitialState g pl = undefined

-- Diese Funktion berechnet, welchen Zug Sie in einer bestimmten Spielsituation ausführen wollen.
-- Sie erhalten wieder einen frischen Zufallszahlengenerator (g) und die Angabe, als welcher Spieler sie spielen (pl).
-- Außerdem erhalten Sie den aktuellen Zustand Ihrer Strategie (s) und das aktuelle Spielbrett (board).
--
-- Die Rückgabe Ihrer Funktion muss der auszuführende Zug sowie der neue Zustand Ihrer Strategie sein.
myComputeMove :: RandomGen g => g -> MyState -> Player -> Board -> (Position, MyState)
myComputeMove g s pl board = (undefined, undefined)

-- Dies bitte NICHT verändern; gewertet werden myInitialState/myComputeMove
strategy :: Strategy MyState
strategy = Strategy myInitialState myComputeMove

{-TTEW-}