};
var $elm$core$Basics$negate = function (n) {
	return -n;
};
var $author$project$Queens$listToTuple = function (l) {
	if (l.b && l.b.b) {
		var x = l.a;
		var _v1 = l.b;
		var y = _v1.a;
		var xs = _v1.b;
		return _Utils_Tuple2(x, y);
	} else {
		return _Utils_Tuple2(-1, -1);
	}

var $author$project$Queens$solutionDecoder = A2(
	$elm$json$Json$Decode$field,
	'queens',
	$elm$json$Json$Decode$list(
		$elm$json$Json$Decode$list($elm$json$Json$Decode$int)));

var $elm$core$Basics$negate = function (n) {
	return -n;
};
var $author$project$Queens$solutionDecoder = function () {
	var listToTuple = function (l) {
		if (l.b && l.b.b) {
			var x = l.a;
			var _v1 = l.b;
			var y = _v1.a;
			var xs = _v1.b;
			return _Utils_Tuple2(x, y);
		} else {
			return _Utils_Tuple2(-1, -1);
		}
	};
	return A2(
		$elm$json$Json$Decode$field,
		'queens',
		$elm$json$Json$Decode$list(
			A2(
				$elm$json$Json$Decode$map,
				listToTuple,
				$elm$json$Json$Decode$list($elm$json$Json$Decode$int))));
}();

										A2(
											$elm$core$List$map,
											function (l) {
												return $author$project$Queens$listToTuple(l);
											},
											sol))),

										sol)),

				$mdgriffith$elm_ui$Element$px(100)),

				$mdgriffith$elm_ui$Element$px(150)),

	var b = F2(
		function (s, m) {

	var but = F2(
		function (name, msg) {

					label: $mdgriffith$elm_ui$Element$text(s),
					onPress: $elm$core$Maybe$Just(m)

					label: $mdgriffith$elm_ui$Element$text(name),
					onPress: $elm$core$Maybe$Just(msg)

							A2(b, 'Clear', $author$project$Queens$ClearQueens)

							A2(but, 'Clear', $author$project$Queens$ClearQueens)

import Html.Attributes as HAttr exposing (style, src, width, height)

import Html.Attributes as HAttr exposing 
    (style, src, width, height)

import Element.Input exposing (button, slider, labelAbove, defaultThumb)

import Element.Input exposing 
    (button, slider, labelAbove, defaultThumb)

import Json.Decode exposing (Decoder, field, list, int)

import Json.Decode as Decode exposing (Decoder, field, list, int)

    | ReceivedSolution (Result Http.Error (List (List Int)))

    | ReceivedSolution (Result Http.Error (List (Int, Int)))

        formatQueen (i,j) = "&queen=" ++ String.fromInt i ++ ":" ++ String.fromInt j

        formatQueen (i,j) = "&queen=" ++ String.fromInt i ++ ":" ++ String.fromInt j

                    newModel = { model | fixedQueens = Set.insert (i,j) model.fixedQueens }

                    newModel = 
                        { model 
                            | fixedQueens = Set.insert (i,j) model.fixedQueens
                        }

            -- Removing a fixed queen 'actually' removes it
            -- but removing a solution queen will turn it into a fixed queen

            -- This only requests a solution if there are more than
            -- 0 fixed queens

                    ( newModel, if Set.size newModel.fixedQueens > 0 then requestSolution newModel else Cmd.none)

                    ( newModel
                    , if Set.size newModel.fixedQueens > 0 
                        then requestSolution newModel
                        else Cmd.none
                    )

            ReceivedSolution maybeSol
                -> case maybeSol of

            ReceivedSolution maybeSol -> case maybeSol of

                    Ok(sol) ->
                        ( { model 
                            | status = Just Solved
                            , solutionQueens = Set.fromList 
                                <| List.filter (\x -> not (Set.member x model.fixedQueens)) 
                                <| List.map (\l -> listToTuple l) sol
                          }
                        , Cmd.none
                        )

                Ok(sol) ->
                    ( { model 
                        | status = Just Solved
                        , solutionQueens = Set.fromList 
                            <| List.filter (\x -> not (Set.member x model.fixedQueens)) 
                            <| sol
                      }
                    , Cmd.none
                    )

                    Err(err) -> ( { model | status = Just Unsolvable, solutionQueens = Set.empty}, Cmd.none )

                Err(err) -> 
                    ( { model | status = Just Unsolvable
                      , solutionQueens = Set.empty
                      }
                    , Cmd.none
                    )

listToTuple : List Int -> (Int,Int)
listToTuple l = 
    case l of
        (x::y::xs) -> (x,y)
        _ -> (-1, -1)

solutionDecoder : Decoder (List (Int, Int))
solutionDecoder = 
    let
        listToTuple l = 
            case l of
                (x::y::xs) -> (x,y)
                _ -> (-1, -1)
    in
        field "queens" <| list (Decode.map listToTuple (list int))

        b s m = button 

        but name msg = button 

            ( { onPress = Just m, label = text s} )

            <| { onPress = Just msg, label = text name }

            [ Element.width <| px 100
            , behindContent

            [ Element.width <| px 150
            , behindContent -- the bar of the slider

                [ el [centerX, paddingXY 0 20] (text "Queens")
                , el [] (html <| board model)
                , row [spacing 10, Element.width fill] [ status, sizeSlider, b "Clear" ClearQueens]

                [ el [centerX, paddingXY 0 20] (text "Queens") -- heading
                , el [] (html <| board model) -- board
                , row -- controls
                    [spacing 10, Element.width fill]
                    [ status, sizeSlider, but "Clear" ClearQueens]

            
solutionDecoder : Decoder (List (List Int))
solutionDecoder = field "queens" <| list (list int)