package reddit

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"testing"

	"github.com/stretchr/testify/require"
)

var expectedUserFlairs = []*Flair{
	{
		ID:   "b8a1c822-3feb-11e8-88e1-0e5f55d58ce0",
		Type: "text",
		Text: "Beginner",

		Color:           "dark",
		BackgroundColor: "",
		CSSClass:        "Beginner1",

		Editable: false,
		ModOnly:  false,
	},
	{
		ID:   "b8ea0fce-3feb-11e8-af7a-0e263a127cf8",
		Text: "Moderator",
		Type: "text",

		Color:           "dark",
		BackgroundColor: "",
		CSSClass:        "Moderator1",

		Editable: false,
		ModOnly:  true,
	},
}

var expectedPostFlairs = []*Flair{
	{
		ID:   "305b503e-da60-11ea-9681-0e9f1d580d2d",
		Type: "richtext",
		Text: "test",

		Color:           "light",
		BackgroundColor: "#373c3f",
		CSSClass:        "test",

		Editable: false,
		ModOnly:  true,
	},
}

var expectedListUserFlairs = []*FlairSummary{
	{
		User: "TestUser1",
		Text: "TestFlair1",
	},
	{
		User: "TestUser2",
		Text: "TestFlair2",
	},
}

var expectedFlairTemplate = &FlairTemplate{
	ID:      "be0a6110-f23c-11ea-862f-0e08890d7323",
	Type:    "LINK_FLAIR",
	ModOnly: false,

	AllowableContent: "all",
	Text:             "lol",
	TextType:         "richtext",
	TextColor:        "dark",
	TextEditable:     false,
	RichText: []map[string]string{
		{"e": "text", "t": "lol"},
	},

	OverrideCSS:     false,
	MaxEmojis:       1,
	BackgroundColor: "#fafafa",
	CSSClass:        "",
}

func TestFlairService_GetUserFlairs(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	blob, err := readFileContents("../testdata/flair/user-flairs.json")
	require.NoError(t, err)

	mux.HandleFunc("/r/testsubreddit/api/user_flair_v2", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodGet, r.Method)
		fmt.Fprint(w, blob)
	})

	userFlairs, _, err := client.Flair.GetUserFlairs(ctx, "testsubreddit")
	require.NoError(t, err)
	require.Equal(t, expectedUserFlairs, userFlairs)
}

func TestFlairService_GetPostFlairs(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	blob, err := readFileContents("../testdata/flair/post-flairs.json")
	require.NoError(t, err)

	mux.HandleFunc("/r/testsubreddit/api/link_flair_v2", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodGet, r.Method)
		fmt.Fprint(w, blob)
	})

	postFlairs, _, err := client.Flair.GetPostFlairs(ctx, "testsubreddit")
	require.NoError(t, err)
	require.Equal(t, expectedPostFlairs, postFlairs)
}

func TestFlairService_ListUserFlairs(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	blob, err := readFileContents("../testdata/flair/list-user-flairs.json")
	require.NoError(t, err)

	mux.HandleFunc("/r/testsubreddit/api/flairlist", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodGet, r.Method)
		fmt.Fprint(w, blob)
	})

	userFlairs, _, err := client.Flair.ListUserFlairs(ctx, "testsubreddit")
	require.NoError(t, err)
	require.Equal(t, expectedListUserFlairs, userFlairs)
}

func TestFlairService_Configure(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/r/testsubreddit/api/flairconfig", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_enabled", "true")
		form.Set("flair_position", "right")
		form.Set("flair_self_assign_enabled", "false")
		form.Set("link_flair_position", "left")
		form.Set("link_flair_self_assign_enabled", "false")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)
	})

	_, err := client.Flair.Configure(ctx, "testsubreddit", nil)
	require.EqualError(t, err, "request: cannot be nil")

	_, err = client.Flair.Configure(ctx, "testsubreddit", &ConfigureFlairRequest{
		UserFlairEnabled:           Bool(true),
		UserFlairPosition:          "right",
		UserFlairSelfAssignEnabled: Bool(false),
		PostFlairPosition:          "left",
		PostFlairSelfAssignEnabled: Bool(false),
	})
	require.NoError(t, err)
}

func TestFlairService_Enable(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/r/testsubreddit/api/setflairenabled", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_enabled", "true")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)
	})

	_, err := client.Flair.Enable(ctx, "testsubreddit")
	require.NoError(t, err)
}

func TestFlairService_Disable(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/r/testsubreddit/api/setflairenabled", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_enabled", "false")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)
	})

	_, err := client.Flair.Disable(ctx, "testsubreddit")
	require.NoError(t, err)
}

func TestFlairService_UpsertUserTemplate(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	blob, err := readFileContents("../testdata/flair/flair-template.json")
	require.NoError(t, err)

	mux.HandleFunc("/r/testsubreddit/api/flairtemplate_v2", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_type", "USER_FLAIR")
		form.Set("allowable_content", "all")
		form.Set("text", "testtext")
		form.Set("text_color", "dark")
		form.Set("text_editable", "false")
		form.Set("mod_only", "true")
		form.Set("max_emojis", "5")
		form.Set("background_color", "transparent")
		form.Set("css_class", "testclass")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)

		fmt.Fprint(w, blob)
	})

	_, _, err = client.Flair.UpsertUserTemplate(ctx, "testsubreddit", nil)
	require.EqualError(t, err, "request: cannot be nil")

	flairTemplate, _, err := client.Flair.UpsertUserTemplate(ctx, "testsubreddit", &FlairTemplateCreateOrUpdateRequest{
		AllowableContent: "all",
		ModOnly:          Bool(true),
		Text:             "testtext",
		TextColor:        "dark",
		TextEditable:     Bool(false),
		MaxEmojis:        Int(5),
		BackgroundColor:  "transparent",
		CSSClass:         "testclass",
	})
	require.NoError(t, err)
	require.Equal(t, expectedFlairTemplate, flairTemplate)
}

func TestFlairService_UpsertPostTemplate(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	blob, err := readFileContents("../testdata/flair/flair-template.json")
	require.NoError(t, err)

	mux.HandleFunc("/r/testsubreddit/api/flairtemplate_v2", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_type", "LINK_FLAIR")
		form.Set("flair_template_id", "testid")
		form.Set("allowable_content", "text")
		form.Set("text", "testtext")
		form.Set("text_color", "light")
		form.Set("text_editable", "true")
		form.Set("mod_only", "false")
		form.Set("background_color", "#fafafa")
		form.Set("css_class", "testclass")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)

		fmt.Fprint(w, blob)
	})

	_, _, err = client.Flair.UpsertPostTemplate(ctx, "testsubreddit", nil)
	require.EqualError(t, err, "request: cannot be nil")

	flairTemplate, _, err := client.Flair.UpsertPostTemplate(ctx, "testsubreddit", &FlairTemplateCreateOrUpdateRequest{
		ID:               "testid",
		AllowableContent: "text",
		ModOnly:          Bool(false),
		Text:             "testtext",
		TextColor:        "light",
		TextEditable:     Bool(true),
		BackgroundColor:  "#fafafa",
		CSSClass:         "testclass",
	})
	require.NoError(t, err)
	require.Equal(t, expectedFlairTemplate, flairTemplate)
}

func TestFlairService_Delete(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/r/testsubreddit/api/deleteflair", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("name", "testuser")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)
	})

	_, err := client.Flair.Delete(ctx, "testsubreddit", "testuser")
	require.NoError(t, err)
}

func TestFlairService_DeleteTemplate(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/r/testsubreddit/api/deleteflairtemplate", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_template_id", "testtemplate")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)
	})

	_, err := client.Flair.DeleteTemplate(ctx, "testsubreddit", "testtemplate")
	require.NoError(t, err)
}

func TestFlairService_DeleteAllUserTemplates(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/r/testsubreddit/api/clearflairtemplates", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_type", "USER_FLAIR")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)
	})

	_, err := client.Flair.DeleteAllUserTemplates(ctx, "testsubreddit")
	require.NoError(t, err)
}

func TestFlairService_DeleteAllPostTemplates(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/r/testsubreddit/api/clearflairtemplates", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)

		form := url.Values{}
		form.Set("api_type", "json")
		form.Set("flair_type", "LINK_FLAIR")

		err := r.ParseForm()
		require.NoError(t, err)
		require.Equal(t, form, r.PostForm)
	})

	_, err := client.Flair.DeleteAllPostTemplates(ctx, "testsubreddit")
	require.NoError(t, err)
}

func TestFlairService_ReorderUserTemplates(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/api/v1/testsubreddit/flair_template_order/USER_FLAIR", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPatch, r.Method)

		var ids []string
		err := json.NewDecoder(r.Body).Decode(&ids)
		require.NoError(t, err)
		require.Equal(t, []string{"test1", "test2", "test3", "test4"}, ids)
	})

	_, err := client.Flair.ReorderUserTemplates(ctx, "testsubreddit", []string{"test1", "test2", "test3", "test4"})
	require.NoError(t, err)
}

func TestFlairService_ReorderPostTemplates(t *testing.T) {
	client, mux, teardown := setup()
	defer teardown()

	mux.HandleFunc("/api/v1/testsubreddit/flair_template_order/LINK_FLAIR", func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPatch, r.Method)

		var ids []string
		err := json.NewDecoder(r.Body).Decode(&ids)
		require.NoError(t, err)
		require.Equal(t, []string{"test1", "test2", "test3", "test4"}, ids)
	})

	_, err := client.Flair.ReorderPostTemplates(ctx, "testsubreddit", []string{"test1", "test2", "test3", "test4"})
	require.NoError(t, err)
}