test.hs

{-# LANGUAGE OverloadedStrings #-}

module Lib where

import           RIO hiding (lines)
import qualified RIO.Text as T

import           Data.Aeson (FromJSON (..), ToJSON (..), object, withObject,
                             (.:), (.=))
import           Data.Aeson.Encode.Pretty (encodePretty)
import           Data.Scrapbox (ParseError, commonmarkToScrapbox,
                                optFilterRelativePathLink, optSectionHeading,
                                scrapboxToCommonmark)
import           Data.Time (UTCTime)
import           Data.Time.Clock.POSIX (POSIXTime, getPOSIXTime,
                                        utcTimeToPOSIXSeconds)
import           Network.HTTP.Simple (getResponseBody, httpJSON, parseRequest)
import qualified RIO.ByteString.Lazy as BL

data QiitaBlogPost = QiitaBlogPost
    { qbpTitle     :: !Text
    , qbpCreatedAt :: !UTCTime
    , qbpBody      :: !Text
    } deriving (Show)

instance FromJSON QiitaBlogPost where
    parseJSON = withObject "qiita blog post" $ \o -> do
        title     <- o .: "title"
        createdAt <- o .: "created_at"
        body      <- o .: "body"
        return $ QiitaBlogPost title createdAt body

data ScrapboxPage = ScrapboxPage
    { spTitle   :: !Text
    , spCreated :: !Integer
    , spUpdated :: !Integer
    , spLines   :: ![Text]
    } deriving Show

instance ToJSON ScrapboxPage where
    toJSON (ScrapboxPage title created updated lines) = object
        [ "title"   .= title
        , "created" .= created
        , "updated" .= updated
        , "lines"   .= lines
        ]

instance FromJSON ScrapboxPage where
    parseJSON = withObject "Scrapbox page" $ \o -> do
        title   <- o .: "title"
        created <- o .: "created"
        updated <- o .: "updated"
        lines   <- o .: "lines"
        return $ ScrapboxPage title created updated lines

data ScrapboxBackup = ScrapboxBackup
    { sbName        :: !Text
    , sbDisplayname :: !Text
    , sbExported    :: !Integer
    , sbPages       :: ![ScrapboxPage]
    } deriving Show

instance ToJSON ScrapboxBackup where
    toJSON (ScrapboxBackup name displayname exported pages) = object
        [ "name"        .= name
        , "displayName" .= displayname
        , "exported"    .= exported
        , "pages"       .= pages
        ]

instance FromJSON ScrapboxBackup where
    parseJSON = withObject "Scrapbox backup" $ \o -> do
        name        <- o .: "name"
        displayname <- o .: "displayName"
        exported    <- o .: "exported"
        pages       <- o .: "pages"
        pure $ ScrapboxBackup name displayname exported pages

toScrapboxPage :: QiitaBlogPost -> ScrapboxPage
toScrapboxPage (QiitaBlogPost title createdAt body) =
  let date       = round $ utcTimeToPOSIXSeconds createdAt
      parsedPage = commonmarkToScrapbox
        [optSectionHeading, optFilterRelativePathLink]
        body
  in  ScrapboxPage title date date (title : T.lines parsedPage)

toScrapboxBackup :: Text -> POSIXTime -> [QiitaBlogPost] -> ScrapboxBackup
toScrapboxBackup title createdTime qiitaPosts =
  let scrapboxpages = map toScrapboxPage qiitaPosts
  in  ScrapboxBackup title title (round createdTime) scrapboxpages

newtype UserName = UserName String

getQiitaBlogPostHttp :: UserName -> IO [QiitaBlogPost]
getQiitaBlogPostHttp (UserName username) = do
    req <- parseRequest $ mconcat
        [ "https://qiita.com/api/v2/items?query=user%3A"
        , username
        ]
    getResponseBody <$> httpJSON req

mkScrapboxBackUp :: [QiitaBlogPost] -> IO ScrapboxBackup
mkScrapboxBackUp qiitaPosts = do
  currTime   <- getPOSIXTime
  return $ toScrapboxBackup "Qiita backup" currTime qiitaPosts

mkScrapboxBackupJSON :: IO ()
mkScrapboxBackupJSON = do
    let username = UserName "HirotoShioi"
    blogposts <- getQiitaBlogPostHttp username
    backup    <- mkScrapboxBackUp blogposts
    writeFileBinary "./backup.json" (BL.toStrict $ encodePretty backup)

toCommonmarks :: ScrapboxBackup -> Either ParseError [(Text, Text)]
toCommonmarks (ScrapboxBackup _ _ _ pages) = forM pages $ \page -> do
    let body = T.unlines $ spLines page
    md <- scrapboxToCommonmark [] body
    return (spTitle page, md)

scrapboxbackupToMds :: IO ()
scrapboxbackupToMds = do
    let username = UserName "HirotoShioi"
    qiitaPosts     <- getQiitaBlogPostHttp username
    scrapboxBackup <- mkScrapboxBackUp qiitaPosts
    mds <- either (error "failed") return (toCommonmarks scrapboxBackup)
    mapM_ (\(title, md) -> writeFileUtf8 ("./markdowns/" <> T.unpack title <> ".md") md) mds