{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}

module AddressSpec where

import qualified Data.Map as M
import Data.Text hiding (all, map)
import qualified Data.Text as T
import qualified Data.Vector as V
import Faker hiding (defaultFakerSettings)
import Faker.Address
import Faker.Internal
-- import Faker.Provider.Address
import Test.Hspec
import TestImport

fakerException :: Selector FakerException
fakerException = const True

spec :: Spec
spec = do
  describe "Address" $ do
    -- it "parses countries for defaultSettings" $ do
    --   ctries <- countryProvider defaultFakerSettings
    --   ctries `shouldSatisfy` (\x -> V.length x >= 40)
    -- it "parses countryByCode for defaultSettings" $ do
    --   ctries <- countryByCodeProvider defaultFakerSettings
    --   ctries `shouldSatisfy` (\x -> Prelude.length (M.toList x) >= 40)
    -- it "parses countries for other locales" $ do
    --   locales <- populateLocales
    --   let settings :: [FakerSettings] =
    --         map (\l -> setLocale l defaultFakerSettings) locales
    --       ctries :: IO [V.Vector Text] = mapM countryProvider settings
    --   ctries' :: [V.Vector Text] <- ctries
    --   let exp :: [Bool] = map (\x -> V.length x >= 10) ctries'
    --   True `shouldBe` (all (\x -> x == True) exp)
    it "produces random integer text" $ do
      let txt = interpolateNumbers defaultFakerSettings "#####"
      let num :: Int = read (unpack txt)
      num `shouldSatisfy` (\x -> x >= 0 && T.length txt == 5)
    it "produces random integer only for hash" $ do
      let txt = interpolateNumbers defaultFakerSettings "ab-##"
      txt `shouldSatisfy` (\x -> T.length x == 5 && (T.take 3 x == "ab-"))
    it "produces random alphabets" $ do
      let txt = interpolateString defaultFakerSettings "????"
      txt `shouldBe` "XJZS"
    it "preserves unwanted things" $ do
      let txt = interpolateString defaultFakerSettings "32-????"
      txt `shouldBe` "32-XJZS"
    it "preserves unwanted things and works with numbers" $ do
      txt <-
        resolveUnresolved
          defaultFakerSettings
          (pure $ pure $ "32-????-####")
          (\s t -> pure t)
      txt `shouldBe` "32-XJZS-1534"
    it "doesn't get confused with garbage" $ do
      txt <-
        resolveUnresolved
          defaultFakerSettings
          (pure $ pure $ "abjakf-324jak")
          (\s t -> pure t)
      txt `shouldBe` "abjakf-324jak"
    it "resolve field" $ do
      let field = resolveFields "#{community_prefix} #{community_suffix}"
      field `shouldBe` ["community_prefix", "community_suffix"]
    it "resolve field with dot" $ do
      let field =
            resolveFields "#{city_prefix} #{Name.first_name}#{city_suffix}"
      field `shouldBe` ["city_prefix", "Name.first_name", "city_suffix"]
    it "resolve field with dot (2)" $ do
      let field = resolveFields "#{Name.last_name} #{street_suffix}"
      field `shouldBe` ["Name.last_name", "street_suffix"]
    it "resolve field with commas" $ do
      let field =
            resolveFields
              "#{secondary_address} #{street_address}, #{city}, #{state_abbr} #{zip_code}"
      field `shouldBe`
        [ "secondary_address"
        , "street_address"
        , "city"
        , "state_abbr"
        , "zip_code"
        ]
    -- it "resolveAddressField" $ do
    --   item <- resolveAddressField defaultFakerSettings "community_suffix"
    --   item `shouldSatisfy` (\x -> T.length x > 0)
    it "uncons2" $ do
      let item = uncons2 "hello"
      item `shouldBe` Just ("he" :: String, "llo" :: Text)
    describe "operateField" $ do
      it "sample example" $ do
        let item = operateField "#{hello} #{world}" "jam"
        item `shouldBe` "jam #{world}"
      it "leading space example" $ do
        let item = operateField " #{hello} #{world}" "jam"
        item `shouldBe` " jam #{world}"
      it "trailing chars" $ do
        let item = operateField " #{hello} #{world} kool" "jam"
        item `shouldBe` " jam #{world} kool"
      it "edge case" $ do
        let item = operateField "this is" "jam"
        item `shouldBe` "this is"
    describe "operateFields" $ do
      it "sample example" $ do
        let item = operateFields "#{hello} #{world}" ["jam", "cream"]
        item `shouldBe` "jam cream"
      it "leading space example" $ do
        let item = operateFields " #{hello} #{world}" ["jam", "cream"]
        item `shouldBe` " jam cream"
      it "extra arguments" $ do
        let item =
              operateFields " #{hello} #{world} kool" ["jam", "kool", "name"]
        item `shouldBe` " jam kool kool"
    -- it "resolveAddressText" $ do
    --   item <-
    --     resolveAddressText
    --       defaultFakerSettings
    --       "#{community_prefix} #{community_suffix}"
    --   item `shouldSatisfy` (\x -> T.length x > 0 && T.any (== ' ') item)
    -- describe "Resolver check" $ do
    --   it "community" $ do
    --     item <-
    --       resolveAddressText
    --         defaultFakerSettings
    --         "#{community_prefix} #{community_suffix}"
    --     item `shouldSatisfy` (\x -> T.length x >= 5)
      -- it "community via function" $ do
      --   comm <- communityProvider defaultFakerSettings
      --   item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
      --   item `shouldSatisfy` (\x -> T.length x >= 5)
      -- it "building_number" $ do
      --   comm <- buildingNumberProvider defaultFakerSettings
      --   item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
      --   item `shouldSatisfy` (\x -> T.length x >= 3)
      -- it "secondary_address" $ do
      --   comm <- secondaryAddressProvider defaultFakerSettings
      --   item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
      --   item `shouldSatisfy` (\x -> T.length x >= 5)
      -- it "street_address" $ do
      --   item <-
      --     resolveAddressText
      --       defaultFakerSettings
      --       "#{Name.last_name} #{street_suffix}"
      --   item `shouldSatisfy` (\x -> T.length x >= 5)
      -- it "street_address via function" $ do
      --   comm <- streetAddressProvider defaultFakerSettings
      --   item <- resolveUnresolved defaultFakerSettings comm resolveAddressText
      --   item `shouldSatisfy` (\x -> T.length x >= 5)
    describe "Address functions" $ do
      it "basic check" $ do
        fakeCountry <- generate country
        fakeCountry `shouldBe` "Ecuador"
      -- it "check community equality" $ do
      --   let community1 :: Fake Text
      --       community1 =
      --         Fake
      --           (cachedRandomUnresolvedVec
      --              "address"
      --              "community"
      --              communityProvider
      --              resolveAddressText)
      --   c1 <- generate community1
      --   c2 <- generate community
      --   c1 `shouldBe` c2
      -- it "check city prefix equality" $ do
      --   let cityPrefix1 :: Fake Text
      --       cityPrefix1 =
      --         Fake
      --           (cachedRandomVec
      --              "address"
      --              "cityPrefix"
      --              addressCityPrefixProvider)
      --   c1 <- generate cityPrefix1
      --   c2 <- generate cityPrefix
      --   c1 `shouldBe` c2
      it "Monad instance of Fake" $ do
        let someCountry :: Fake Text
            someCountry = do
              c1 <- country
              pure c1
        fakeCountry <- generate someCountry
        fakeCountry `shouldBe` "Ecuador"
      it "Equality of normal generation and Monad" $ do
        fakeCountry <- generate country
        let someCountry :: Fake Text
            someCountry = do
              c1 <- country
              pure c1
        c2 <- generate someCountry
        fakeCountry `shouldBe` c2
      it "Monad instance of Fake (tuple)" $ do
        let someCountry :: Fake (Text, Text)
            someCountry = do
              c1 <- country
              c2 <- country
              pure (c1, c2)
        fakeCountry <- generate someCountry
        fakeCountry `shouldBe` ("Ecuador", "French Guiana")
      it "Non equality of sequence" $ do
        let someCountry :: Fake (Text, Text)
            someCountry = do
              c1 <- country
              c2 <- country
              pure (c1, c2)
        (c1, c2) <- generate someCountry
        c1 `shouldNotBe` c2
      it "Resolver based function" $ do
        bno <- generate buildingNumber
        bno `shouldBe` "153"
      it "Resolver fullAddress" $ do
        bno <- generate fullAddress
        bno `shouldSatisfy` (\x -> T.length x > 25)
      it "Resolver based function - monad" $ do
        let someBuilding :: Fake (Text, Text)
            someBuilding = do
              c1 <- buildingNumber
              c2 <- buildingNumber
              pure (c1, c2)
        (c1, c2) <- generate someBuilding
        c1 `shouldNotBe` c2
    describe "Empty data sources" $ do
      -- it "For ee locale, countries is empty" $ do
      --   ctries <- countryProvider (setLocale "ee" defaultFakerSettings)
      --   ctries `shouldSatisfy` (\x -> V.length x == 0)
      it "For ee locale, throws exception" $ do
        let action =
              generateWithSettings (setLocale "ee" defaultFakerSettings) country
        action `shouldThrow` fakerException