{-# LANGUAGE OverloadedStrings #-}

import Control.Monad (when)
import Control.Monad.Logger (runFileLoggingT, runNoLoggingT)
import Data.HexString
import Data.Maybe (fromJust)
import qualified Data.Text.Encoding as E
import Database.Persist
import Database.Persist.Sqlite
import System.Directory
import Test.HUnit
import Test.Hspec
import ZcashHaskell.Orchard (isValidUnifiedAddress, parseAddress)
import ZcashHaskell.Sapling
  ( decodeSaplingOutputEsk
  , encodeSaplingAddress
  , getSaplingNotePosition
  , getSaplingWitness
  , isValidShieldedAddress
  , updateSaplingCommitmentTree
  )
import ZcashHaskell.Transparent
  ( decodeExchangeAddress
  , decodeTransparentAddress
  )
import ZcashHaskell.Types
  ( DecodedNote(..)
  , OrchardSpendingKey(..)
  , Phrase(..)
  , SaplingCommitmentTree(..)
  , SaplingReceiver(..)
  , SaplingSpendingKey(..)
  , Scope(..)
  , ShieldedOutput(..)
  , TxError(..)
  , ZcashNet(..)
  )
import Zenith.Core
import Zenith.DB
import Zenith.Types

main :: IO ()
main = do
  checkDbFile <- doesFileExist "test.db"
  when checkDbFile $ removeFile "test.db"
  hspec $ do
    describe "Database tests" $ do
      it "Create table" $ do
        s <- runSqlite "test.db" $ do runMigration migrateAll
        s `shouldBe` ()
      describe "Wallet Table" $ do
        it "insert wallet record" $ do
          s <-
            runSqlite "test.db" $ do
              insert $
                ZcashWallet
                  "Main Wallet"
                  (ZcashNetDB MainNet)
                  (PhraseDB $
                   Phrase
                     "one two three four five six seven eight nine ten eleven twelve")
                  2000000
                  0
          fromSqlKey s `shouldBe` 1
        it "read wallet record" $ do
          s <-
            runSqlite "test.db" $ do
              selectList [ZcashWalletBirthdayHeight >. 0] []
          length s `shouldBe` 1
        it "modify wallet record" $ do
          s <-
            runSqlite "test.db" $ do
              let recId = toSqlKey 1 :: ZcashWalletId
              update recId [ZcashWalletName =. "New Wallet"]
              get recId
          "New Wallet" `shouldBe` maybe "None" zcashWalletName s
        it "delete wallet record" $ do
          s <-
            runSqlite "test.db" $ do
              let recId = toSqlKey 1 :: ZcashWalletId
              delete recId
              get recId
          "None" `shouldBe` maybe "None" zcashWalletName s
      describe "Wallet function tests:" $ do
        it "Save Wallet:" $ do
          pool <- runNoLoggingT $ initPool "test.db"
          zw <-
            saveWallet pool $
            ZcashWallet
              "Testing"
              (ZcashNetDB MainNet)
              (PhraseDB $
               Phrase
                 "cloth swing left trap random tornado have great onion element until make shy dad success art tuition canvas thunder apple decade elegant struggle invest")
              2200000
              0
          zw `shouldNotBe` Nothing
        it "Save Account:" $ do
          pool <- runNoLoggingT $ initPool "test.db"
          s <-
            runSqlite "test.db" $ do
              selectList [ZcashWalletName ==. "Testing"] []
          za <- saveAccount pool =<< createZcashAccount "TestAccount" 0 (head s)
          za `shouldNotBe` Nothing
        it "Save address:" $ do
          pool <- runNoLoggingT $ initPool "test.db"
          acList <-
            runSqlite "test.db" $
            selectList [ZcashAccountName ==. "TestAccount"] []
          zAdd <-
            saveAddress pool =<<
            createWalletAddress "Personal123" 0 MainNet External (head acList)
          addList <-
            runSqlite "test.db" $
            selectList
              [ WalletAddressName ==. "Personal123"
              , WalletAddressScope ==. ScopeDB External
              ]
              []
          getUA (walletAddressUAddress (entityVal $ head addList)) `shouldBe`
            "u1trd8cvc6265ywwj4mmvuznsye5ghe2dhhn3zy8kcuyg4vx3svskw9r2dedp5hu6m740vylkqc34t4w9eqkl9fyu5uyzn3af72jg235440ke6tu5cf994eq85n97x69x9824hqejmwz3d8qqthtesrd6gerjupdymldhl9xccejjwfj0dhh9mt4rw4kytp325twlutsxd20rfqhzxu3m"
        it "Address components are correct" $ do
          let ua =
                "utest1mvlny48qd4x94w8vz5u2lrxx0enuquajt72yekgq24p6pjaky3czk6m7x358h7g900ex6gzvdehaekl96qnakjzw8yaasp8y0u3j5jnlfd33trduznh6k3fcn5ek9qc857fgz8ehm37etx94sj58nrkc0k5hurxnuxpcpms3j8uy2t8kt2vy6vetvsfxxdhtjq0yqulqprvh7mf2u3x"
          isValidUnifiedAddress ua `shouldNotBe` Nothing
      describe "Note selection for Tx" $ do
        it "Value less than balance" $ do
          pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
          res <- selectUnspentNotes pool (toSqlKey 1) 14000000
          res `shouldNotBe` ([], [], [])
        it "Value greater than balance" $ do
          pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
          let res = selectUnspentNotes pool (toSqlKey 1) 84000000
          res `shouldThrow` anyIOException
      describe "Testing validation" $ do
        it "Unified" $ do
          let a =
                "utest1zfnw84xuxg0ytzqc008gz0qntr8cvwu4qjsccgtxwdrjywra7uj85x8ldymjc2jd3jvvvhyj3xwsunyvwkr5084t6p5gmvzwdgvwpflrpd6a3squ2dp8vt7cxngmwk30l44wkmvyfegypqmezxfnqj572lr779gkqj5xekp66uv4jga58alnc5j7tuank758zd96ap4f09udg6y6pxu"
          True `shouldBe`
            (case isValidUnifiedAddress (E.encodeUtf8 a) of
               Just _a1 -> True
               Nothing ->
                 isValidShieldedAddress (E.encodeUtf8 a) ||
                 (case decodeTransparentAddress (E.encodeUtf8 a) of
                    Just _a3 -> True
                    Nothing ->
                      case decodeExchangeAddress (E.encodeUtf8 a) of
                        Just _a4 -> True
                        Nothing -> False))
        it "Sapling" $ do
          let a =
                "ztestsapling1tgjr4zppwk4ne8xy6gdq4z2gwq7dmf5jq8z2ctpn8nlmtse0a74fa5z0m8z383gmpgqz6q6duu4"
          True `shouldBe`
            (case isValidUnifiedAddress (E.encodeUtf8 a) of
               Just _a1 -> True
               Nothing ->
                 isValidShieldedAddress (E.encodeUtf8 a) ||
                 (case decodeTransparentAddress (E.encodeUtf8 a) of
                    Just _a3 -> True
                    Nothing ->
                      case decodeExchangeAddress (E.encodeUtf8 a) of
                        Just _a4 -> True
                        Nothing -> False))
        it "Transparent" $ do
          let a = "tmGfVZHuGVJ5vcLAgBdkUU4w7fLTRE5nXm3"
          True `shouldBe`
            (case isValidUnifiedAddress (E.encodeUtf8 a) of
               Just _a1 -> True
               Nothing ->
                 isValidShieldedAddress (E.encodeUtf8 a) ||
                 (case decodeTransparentAddress (E.encodeUtf8 a) of
                    Just _a3 -> True
                    Nothing ->
                      case decodeExchangeAddress (E.encodeUtf8 a) of
                        Just _a4 -> True
                        Nothing -> False))
        it "Check Sapling Address" $ do
          let a =
                encodeSaplingAddress TestNet $
                SaplingReceiver
                  "Z$:\136!u\171<\156\196\210\SUB\n\137Hp<\221\166\146\SOH\196\172,3<\255\181\195/\239\170\158\208O\217\197\DC3\197\ESC\n\NUL-"
          a `shouldBe`
            Just
              "ztestsapling1tgjr4zppwk4ne8xy6gdq4z2gwq7dmf5jq8z2ctpn8nlmtse0a74fa5z0m8z383gmpgqz6q6duu4"
      describe "Notes" $ do
        xit "Check Orchard notes" $ do
          pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
          oNotes <- getWalletUnspentOrchNotes pool (toSqlKey 1)
          oNotes `shouldBe` []
        xit "Check Sapling notes" $ do
          pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
          oNotes <- getWalletUnspentSapNotes pool (toSqlKey 4)
          oNotes `shouldBe` []
        xit "Check transparent notes" $ do
          pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
          oNotes <- getWalletUnspentTrNotes pool (toSqlKey 1)
          oNotes `shouldBe` []
      describe "Creating Tx" $ do
        describe "Full" $ do
          it "To Orchard" $ do
            let uaRead =
                  parseAddress
                    "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 3)
                    3026170
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        (Just "Sending memo to orchard")
                    ]
                    Full
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldBe` (hexString "deadbeef")
          it "To Sapling" $ do
            let uaRead =
                  parseAddress
                    "ztestsapling136jp8z89v2jh6kqd5rs4dtvlxym90m43svzdwzxaplyvc5ttzppytpvx80ncllcsqzpmukxjl3y"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 4)
                    3001331
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        (Just "Sending memo to sapling")
                    ]
                    Full
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")
          it "To Transparent" $ do
            let uaRead = parseAddress "tmAmSa4AauSFuJieeanRBjkfnah45ysGtgZ"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 4)
                    3001331
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    Full
                tx `shouldBe`
                  Left
                    (PrivacyPolicyError "Receiver not capable of Full privacy")
          it "To mixed shielded receivers" $ do
            let uaRead =
                  parseAddress
                    "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
            let uaRead2 =
                  parseAddress
                    "ztestsapling136jp8z89v2jh6kqd5rs4dtvlxym90m43svzdwzxaplyvc5ttzppytpvx80ncllcsqzpmukxjl3y"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001331
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        (Just "Sending memo to orchard")
                    , ProposedNote
                        (ValidAddressAPI $ fromJust uaRead2)
                        0.004
                        Nothing
                    ]
                    Full
                tx `shouldBe`
                  Left
                    (PrivacyPolicyError
                       "Combination of receivers not allowed for Full privacy")
        describe "Medium" $ do
          it "To Orchard" $ do
            let uaRead =
                  parseAddress
                    "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        (Just "Sending memo to orchard")
                    ]
                    Medium
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")
          it "To Sapling" $ do
            let uaRead =
                  parseAddress
                    "ztestsapling136jp8z89v2jh6kqd5rs4dtvlxym90m43svzdwzxaplyvc5ttzppytpvx80ncllcsqzpmukxjl3y"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        (Just "Sending memo to sapling")
                    ]
                    Medium
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")
          it "To Transparent" $ do
            let uaRead = parseAddress "tmAmSa4AauSFuJieeanRBjkfnah45ysGtgZ"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 4)
                    3001331
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    Medium
                tx `shouldBe`
                  Left
                    (PrivacyPolicyError "Receiver not capable of Medium privacy")
          it "To mixed shielded receivers" $ do
            let uaRead =
                  parseAddress
                    "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
            let uaRead2 =
                  parseAddress
                    "ztestsapling136jp8z89v2jh6kqd5rs4dtvlxym90m43svzdwzxaplyvc5ttzppytpvx80ncllcsqzpmukxjl3y"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001331
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        (Just "Sending memo to orchard")
                    , ProposedNote
                        (ValidAddressAPI $ fromJust uaRead2)
                        0.004
                        Nothing
                    ]
                    Medium
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")
        describe "Low" $ do
          it "To Orchard" $ do
            let uaRead =
                  parseAddress
                    "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    Low
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")
          it "To Sapling" $ do
            let uaRead =
                  parseAddress
                    "ztestsapling136jp8z89v2jh6kqd5rs4dtvlxym90m43svzdwzxaplyvc5ttzppytpvx80ncllcsqzpmukxjl3y"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    Low
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")
          it "To Transparent" $ do
            let uaRead = parseAddress "tmAmSa4AauSFuJieeanRBjkfnah45ysGtgZ"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    Low
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")
        describe "None" $ do
          it "To Orchard" $ do
            let uaRead =
                  parseAddress
                    "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    None
                tx `shouldBe`
                  Left
                    (PrivacyPolicyError
                       "Shielded recipients not compatible with privacy policy.")
          it "To Sapling" $ do
            let uaRead =
                  parseAddress
                    "ztestsapling136jp8z89v2jh6kqd5rs4dtvlxym90m43svzdwzxaplyvc5ttzppytpvx80ncllcsqzpmukxjl3y"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    None
                tx `shouldBe`
                  Left
                    (PrivacyPolicyError
                       "Shielded recipients not compatible with privacy policy.")
          it "To Transparent" $ do
            let uaRead = parseAddress "tmAmSa4AauSFuJieeanRBjkfnah45ysGtgZ"
            case uaRead of
              Nothing -> assertFailure "wrong address"
              Just ua -> do
                pool <- runNoLoggingT $ initPool "/home/rav/Zenith/zenith.db"
                tx <-
                  runFileLoggingT "zenith.log" $
                  prepareTxV2
                    pool
                    "localhost"
                    18232
                    TestNet
                    (toSqlKey 1)
                    3001372
                    [ ProposedNote
                        (ValidAddressAPI $ fromJust uaRead)
                        0.005
                        Nothing
                    ]
                    None
                case tx of
                  Left e -> assertFailure $ show e
                  Right h -> h `shouldNotBe` (hexString "deadbeef")