module Exercise_11_Sol where

import Data.List
import Network
import System.IO

{-G11.1-}

{- Siehe AssocList_Sol.hs -}

{-G11.2-}

{- Siehe Queue_Sol.hs -}

{-G11.3-}

vocabs = ["i", "more", "more", "now", "want", "won", "wow"]

quasiIdentical :: String -> String -> Bool
quasiIdentical [] [] = False
quasiIdentical (c : cs) (d : ds)
    | c == d = quasiIdentical cs ds
    | otherwise = cs == ds
quasiIdentical _ _ = False

fixTypo :: [String] -> String -> Either [String] String
fixTypo vocabs word = 
    if word `elem` vocabs then Right word else Left quasis
  where quasis = nub (filter (quasiIdentical word) vocabs)

{-H11.1-}

{- Siehe PrioQueue_Sol.hs -}

{-H11.2-}

{- Folgende Funktionen können Sie zur Lösung verwenden:

    -- definiert in Network
    -- erzeugt einen Socket und wartet auf eingehende Verbindungen
    -- Muss nur ein einziges Mal beim Start des Servers aufgerufen werden.
    -- Bsp.: listenOn (PortNumber 80)
    listenOn :: PortID -> IO Socket

    -- definiert in Network
    -- erstellt ein I/O-Handle für eine Verbindung
    -- Kann nach einem Protokolllauf erneut aufgerufen werden.
    -- Für die Bearbeitung der Aufgabe ist nur das Handle notwendig, die anderen Rückgabewerte können ignoriert werden.
    accept :: Socket -> IO (Handle, HostName, PortNumber)

    -- definiert in System.IO
    -- schließt ein I/O-Handle
    -- muss unbedingt nach Beendigung eines Protokolllaufs oder bei vorzeitigem Abbruch aufgerufen werden
    hClose :: Handle -> IO ()

-}

act :: Handle -> (String, String) -> IO ()
act h (captcha, response) = do
  command <- hGetLine h
  case words command of
    ["REGISTER", name] -> do
      let count = length (lines captcha)
      hPutStrLn h ("CHALLENGE " ++ show count)
      hPutStrLn h captcha
      command <- hGetLine h
      case words command of
        ["SOLUTION", response'] -> do
          if response == response' then do
            hPutStrLn h "ACK"
            putStrLn name
          else
            hPutStrLn h "NAK"
          hClose h
        _ ->
          disconnect h "SOLUTION expected"
    _ ->
      disconnect h "REGISTER expected"
  where disconnect h s = do
          hPutStrLn h ("Error: " ++ s)
          hClose h

server :: IO (String, String) -> IO ()
server challenge = withSocketsDo $ do
  sock <- listenOn (PortNumber 8080)
  loop sock
  where loop sock = do
          (h, _, _) <- accept sock
          c <- challenge
          act h c
          loop sock