module Unused.ParserSpec where

import qualified Data.Map.Strict as Map
import           Test.Hspec
import           Unused.Parser
import           Unused.ResultsClassifier
import           Unused.TermSearch
import           Unused.Types

main :: IO ()
main = hspec spec

spec :: Spec
spec = parallel $
    describe "parseResults" $ do
        it "parses from the correct format" $ do
            let r1Matches = [ TermMatch "method_name" "app/path/foo.rb" Nothing 1
                            , TermMatch "method_name" "app/path/other.rb" Nothing 5
                            , TermMatch "method_name" "spec/path/foo_spec.rb" Nothing 10
                            ]
            let r1Results = TermResults "method_name" ["method_name"] r1Matches (Occurrences 1 10) (Occurrences 2 6) (Occurrences 3 16) (Removal Low "used frequently") Nothing

            let r2Matches = [ TermMatch "other" "app/path/other.rb" Nothing 1 ]
            let r2Results = TermResults "other" ["other"] r2Matches (Occurrences 0 0) (Occurrences 1 1) (Occurrences 1 1) (Removal High "occurs once") Nothing

            let (Right config) = loadConfig

            let result = parseResults config $ SearchResults $ r1Matches ++ r2Matches

            result `shouldBe`
                Map.fromList [ ("method_name", r1Results), ("other", r2Results) ]

        it "parses when no config is provided" $ do
            let r1Matches = [ TermMatch "method_name" "app/path/foo.rb" Nothing 1
                            , TermMatch "method_name" "app/path/other.rb" Nothing 5
                            , TermMatch "method_name" "spec/path/foo_spec.rb" Nothing 10
                            ]
            let r1Results = TermResults "method_name" ["method_name"] r1Matches (Occurrences 1 10) (Occurrences 2 6) (Occurrences 3 16) (Removal Low "used frequently") Nothing

            let result = parseResults [] $ SearchResults r1Matches

            result `shouldBe`
                Map.fromList [ ("method_name", r1Results) ]

        it "handles aliases correctly" $ do
            let r1Matches = [ TermMatch "admin?" "app/path/user.rb" Nothing 3 ]

            let r2Matches = [ TermMatch "admin?" "spec/models/user_spec.rb" (Just "be_admin") 2
                            , TermMatch "admin?" "spec/features/user_promoted_to_admin_spec.rb" (Just "be_admin") 2
                            ]


            let (Right config) = loadConfig
            let searchResults = r1Matches ++ r2Matches

            let result = parseResults config $ SearchResults searchResults

            let results = TermResults "admin?" ["admin?", "be_admin"] searchResults (Occurrences 2 4) (Occurrences 1 3) (Occurrences 3 7) (Removal Low "used frequently") Nothing
            result `shouldBe`
                Map.fromList [ ("admin?|be_admin", results) ]

        it "handles empty input" $ do
            let (Right config) = loadConfig
            let result = parseResults config $ SearchResults []
            result `shouldBe` Map.fromList []