module PhotoGrooveTest exposing (..)

import Expect
import Fuzz
import Html.Attributes as Attr
import Json.Decode as J
import Json.Encode as Encode
import PhotoGroove.Internal as Testee exposing (FilterType(..), FilterValues, Message(..), Photo, filterTypeToName, initialModel)
import Test exposing (..)
import Test.Html.Query as Query
import Test.Html.Selector exposing (attribute, tag)


suite : Test
suite =
    concat
        [ describe "photoDecoder"
            [ fuzz2 Fuzz.string Fuzz.int "title always defaults to '(untitled)'" <|
                \url size ->
                    [ ( "url", Encode.string url )
                    , ( "size", Encode.int size )
                    ]
                        |> Encode.object
                        |> J.decodeValue Testee.photoDecoder
                        |> Result.map .title
                        |> Expect.equal (Ok "(untitled)")
            ]
        , describe "update"
            [ describe "slider event sets filter value"
                [ sliderTest Hue .hue
                , sliderTest Ripple .ripple
                , sliderTest Noise .noise
                ]
            , test "when photos are loaded, the first one gets selected" <|
                \_ ->
                    Testee.initialModel
                        |> Testee.update (GotPhotos (Ok <| [ photoFromUrl "1.jpg" ]))
                        |> Tuple.first
                        |> .status
                        |> selectedUrl
                        |> Expect.equal (Just "1.jpg")
            ]
        , describe "view"
            [ test "no photos, no thumbnails" <|
                \_ ->
                    Testee.initialModel
                        |> Testee.view
                        |> Query.fromHtml
                        |> Query.findAll [ tag "img" ]
                        |> Query.count (Expect.equal 0)
            , fuzz (Fuzz.intRange 1 5) "URLs render as thumbnails" <|
                \count ->
                    let
                        urls : List String
                        urls =
                            List.range 1 count
                                |> List.map (\num -> String.fromInt num ++ ".png")

                        photos =
                            List.map photoFromUrl urls

                        checks =
                            List.map thumbnailRendered urls
                    in
                    { initialModel | status = Testee.Loaded photos "" }
                        |> Testee.view
                        |> Query.fromHtml
                        |> Expect.all checks
            ]
        ]


sliderTest : FilterType -> (FilterValues -> Int) -> Test
sliderTest filterType value =
    fuzz Fuzz.int (filterTypeToName filterType) <|
        \amount ->
            Testee.initialModel
                |> Testee.update (ChangedFilter filterType amount)
                |> Tuple.first
                |> .filterValues
                |> value
                |> Expect.equal amount


thumbnailRendered : String -> Query.Single msg -> Expect.Expectation
thumbnailRendered url query =
    query
        |> Query.findAll [ tag "img", attribute (Attr.src (Testee.urlPrefix ++ url)) ]
        |> Query.count (Expect.atLeast 1)


photoFromUrl : String -> Photo
photoFromUrl url =
    { url = url, size = 0, title = "" }


selectedUrl : Testee.Status -> Maybe String
selectedUrl status =
    case status of
        Testee.Loading ->
            Nothing

        Testee.Loaded _ url ->
            Just url

        Testee.Errored _ ->
            Nothing