{-# LANGUAGE RecordWildCards, OverloadedStrings #-}

import Json

import Control.Lens
import Control.Monad               (when)
import Network.Wreq                (get, responseBody)
import Data.Aeson                  (decode, toJSON)
import Data.Maybe                  (fromJust)
import Data.HashMap.Strict         (delete)
import Data.ByteString.Lazy.Char8  (pack)
import System.Console.ArgParser
import System.Process

data ProgArgs = ProgArgs
  { name     :: String
  , url      :: String
  , dnschain :: Bool
  , block    :: Bool
  , raw      :: Bool
  } deriving (Show)

parser :: ParserSpec ProgArgs
parser = ProgArgs
  `parsedBy` reqPos   "name"     `Descr` "Namecoin name id"
  `andBy`    optFlag  "http://dns.dnschain.net/" "url"
                                 `Descr` "Use custom api url"
  `andBy`    boolFlag "dnschain" `Descr` "Use dnschain api"
  `andBy`    boolFlag "block"    `Descr` "Show blockchain data (require local connecton)"
  `andBy`    boolFlag "raw"      `Descr` "Print raw JSON data"

interface :: IO (CmdLnInterface ProgArgs)
interface =
  (`setAppDescr`  "Query the namecoin blockchain") .
  (`setAppEpilog` "Stat rosa pristina nomine, nomina nuda tenemus.") <$>
  mkApp parser

main :: IO ()
main = interface >>= flip runApp exec

exec :: ProgArgs -> IO ()
exec ProgArgs{..} =
  if dnschain
  then doDnschain url name raw
  else doLocal name block

doLocal :: String -> Bool -> IO ()
doLocal name block = do
  out <- readProcess "namecoin-cli" ["name_show", name] ""
  case decode (pack out) of
    Nothing  -> putStrLn "Error parsing data"
    Just res -> do
      pprint $ reparse (res |: "value")
      when block (pprint extra)
      where
        reparse = fromJust . decode . pack
        extra   = toJSON (delete "value" res)

doDnschain :: String -> String -> Bool -> IO ()
doDnschain url name raw = do
  body <- (^. responseBody) <$> get (url ++ name)
  if raw
  then print body
  else putStrLn $
    case decode body of
      Just res -> repr res
      Nothing  -> "Error parsing data"