module Main where

import Data.List (find)
import Data.Maybe (fromMaybe)


data Expression =
  Variable VariableName |
  FieldAccess Expression FieldName |
  MethodInvocation Expression MethodName [Expression] |
  New ClassName [Expression] |
  Cast ClassName Expression

data Class = Class ClassName ClassName [(ClassName, FieldName)] Constructor [Method]

data Constructor = Constructor ClassName [(ClassName, FieldName)] [FieldName] [FieldName]

data Method = Method ClassName MethodName [(ClassName, VariableName)] Expression


type ClassName = String
type FieldName = String
type MethodName = String
type VariableName = String

type ClassTable = [Class]

type Context = [(VariableName, ClassName)]


typeCheckExpression :: ClassTable -> Context -> Expression -> ClassName
typeCheckExpression classTable context expression = undefined


subType :: ClassTable -> ClassName -> ClassName -> Bool
subType classTable className parentClassName = undefined

fields :: ClassTable -> ClassName -> [(ClassName, FieldName)]
fields classTable className = undefined

methodType :: ClassTable -> ClassName -> MethodName -> ([ClassName], ClassName)
methodType classTable className methodName = undefined


main :: IO ()
main = do
  print (typeCheckExpression exampleClassTable [] expression)

exampleClassTable = [

  Class "A" "Object"
    []
    (Constructor "A" [] [] [])
    [],

  Class "B" "Object"
    []
    (Constructor "B" [] [] [])
    [],

  Class "Pair" "Object"
    [("Object", "fst"), ("Object", "snd")]
    (Constructor "Pair" [("Object", "fst"), ("Object", "snd")] [] ["fst", "snd"])
    [Method "Pair" "setfst" [("Object", "newfst")] (New "Pair" [Variable "newfst", FieldAccess (Variable "this") "snd"])]
  ]

expression = FieldAccess (Cast "Pair" (FieldAccess (New "Pair" [New "Pair" [New "A" [], New "B" []], New "A" []]) "fst")) "snd"