module RPGEngine.Parse.Game where

import RPGEngine.Data
import RPGEngine.Data.Defaults
import RPGEngine.Parse.StructElement

-------------------------------- Game --------------------------------

-- TODO
structToGame :: StructElement -> Game
structToGame = undefined

------------------------------- Player -------------------------------

structToPlayer :: StructElement -> Player
structToPlayer (Block block) = structToPlayer' block defaultPlayer
structToPlayer _             = defaultPlayer

structToPlayer' :: [StructElement] -> Player -> Player
structToPlayer' []                                        p = p
structToPlayer' ((Entry(Tag "hp")        val        ):es) p = (structToPlayer' es p){ playerHp  = structToMaybeInt val }
structToPlayer' ((Entry(Tag "inventory") (Block inv)):es) p = (structToPlayer' es p){ inventory = structToItems inv    }
structToPlayer' _                                         _ = defaultPlayer

structToActions :: StructElement -> [([Condition], Action)]
structToActions (Block [])    = []
structToActions (Block block) = structToActions' block []
structToActions _             = []

structToActions' :: [StructElement] -> [([Condition], Action)] -> [([Condition], Action)]
structToActions' []                                                  list = list
structToActions' ((Entry(ConditionList cs) (Regular (Action a))):as) list = structToActions' as ((cs, a):list)
structToActions' _                                                   list = list

------------------------------- Levels -------------------------------

structToLevels :: StructElement -> [Level]
structToLevels (Block struct) = structToLevel <$> struct
structToLevels _              = [defaultLevel]

structToLevel :: StructElement -> Level
structToLevel (Block entries) = structToLevel' entries defaultLevel
structToLevel _               = defaultLevel

structToLevel' :: [StructElement] -> Level -> Level
structToLevel' ((Entry(Tag "layout")   (Regular (Layout layout))):ls) l = (structToLevel' ls l){ RPGEngine.Data.layout = layout       }
structToLevel' ((Entry(Tag "items")    (Block items)            ):ls) l = (structToLevel' ls l){ items    = structToItems items       }
structToLevel' ((Entry(Tag "entities") (Block entities)         ):ls) l = (structToLevel' ls l){ entities = structToEntities entities }
structToLevel' _                                                      _ = defaultLevel

------------------------------- Items --------------------------------

structToItems :: [StructElement] -> [Item]
structToItems items = structToItem <$> items

structToItem :: StructElement -> Item
structToItem (Block block) = structToItem' block defaultItem
structToItem _             = defaultItem

structToItem' :: [StructElement] -> Item -> Item
structToItem' []                                            i = i
structToItem' ((Entry(Tag "id")          (Regular(String id  ))):is) i = (structToItem' is i){ itemId          = id                        }
structToItem' ((Entry(Tag "x")           (Regular(Integer x  ))):is) i = (structToItem' is i){ itemX           = x                         }
structToItem' ((Entry(Tag "y")           (Regular(Integer y  ))):is) i = (structToItem' is i){ itemY           = y                         }
structToItem' ((Entry(Tag "name")        (Regular(String name))):is) i = (structToItem' is i){ itemName        = name                      }
structToItem' ((Entry(Tag "description") (Regular(String desc))):is) i = (structToItem' is i){ itemDescription = desc                      }
structToItem' ((Entry(Tag "value")       val                   ):is) i = (structToItem' is i){ itemValue       = structToMaybeInt val      }
structToItem' ((Entry(Tag "actions")     actions               ):is) i = (structToItem' is i){ itemActions     = structToActions actions   }
structToItem' ((Entry (Tag "useTimes")   useTimes              ):is) i = (structToItem' is i){ useTimes        = structToMaybeInt useTimes }
structToItem' _                                             _ = defaultItem

------------------------------ Entities ------------------------------

structToEntities :: [StructElement] -> [Entity]
structToEntities entities = structToEntity <$> entities

structToEntity :: StructElement -> Entity
structToEntity (Block block) = structToEntity' block defaultEntity
structToEntity _             = defaultEntity

structToEntity' :: [StructElement] -> Entity -> Entity
structToEntity' []                                                     e = e
structToEntity' ((Entry(Tag "id")          (Regular(String id  ))  ):es) e = (structToEntity' es e){ entityId          = id                      }
structToEntity' ((Entry(Tag "x")           (Regular(Integer x  ))  ):es) e = (structToEntity' es e){ entityX           = x                       }
structToEntity' ((Entry(Tag "y")           (Regular(Integer y  ))  ):es) e = (structToEntity' es e){ entityY           = y                       }
structToEntity' ((Entry(Tag "name")        (Regular(String name))  ):es) e = (structToEntity' es e){ entityName        = name                    }
structToEntity' ((Entry(Tag "description") (Regular(String desc))  ):es) e = (structToEntity' es e){ entityDescription = desc                    }
structToEntity' ((Entry(Tag "actions")     actions                 ):es) e = (structToEntity' es e){ entityActions     = structToActions actions }
structToEntity' ((Entry(Tag "value")       val                     ):es) e = (structToEntity' es e){ entityValue       = structToMaybeInt val    }
structToEntity' ((Entry(Tag "hp")          val                     ):es) e = (structToEntity' es e){ entityHp          = structToMaybeInt val    }
structToEntity' ((Entry(Tag "direction")   (Regular(Direction dir))):es) e = (structToEntity' es e){ RPGEngine.Data.direction = dir              }
structToEntity' _                                                      _ = defaultEntity

----------------------------------------------------------------------

structToMaybeInt :: StructElement -> Maybe Int
structToMaybeInt (Regular (Integer val)) = Just val
structToMaybeInt (Regular Infinite)      = Prelude.Nothing
structToMaybeInt _                       = Prelude.Nothing -- TODO

----------------------------------------------------------------------