package settings

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"

	"github.com/FrankenBotDev/FrankenAPI/ent"
	"github.com/FrankenBotDev/FrankenAPI/ent/settings"
	"github.com/FrankenBotDev/FrankenAPI/ent/socialmedia"
	"github.com/FrankenBotDev/FrankenAPI/pkg/logger"
	"github.com/FrankenBotDev/FrankenAPI/pkg/sys"
	"github.com/go-chi/chi/v5"
)

func SettingsRouter() http.Handler {
	r := chi.NewRouter()

	r.Get("/", getServerSettings)
	r.Post("/", createServerSettings)
	r.Put("/", updateServerSettings)
	r.Post("/socialmedia", createSocial)
	r.Put("/socialmedia", updateSocial)
	r.Delete("/socialmedia", deleteSocial)
	r.Get("/socialmedia", getSocial)
	return r
}

/* ==========================================================
ROUTE DEFINITIONS
=========================================================== */
func createServerSettings(w http.ResponseWriter, r *http.Request) {

	// fetch data
	settingsJson := make(map[string]any)
	settingsData := sys.ProccessRequest(w, r.Body)
	if settingsData == nil {
		return
	}

	// process data
	err := json.Unmarshal(settingsData, &settingsJson)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_proccess_data", errors.New("request data could not be proccessed"))
	}

	if settingsJson["commiterid"] != "" {
		if settingsJson["serverid"].(string) != "" {
			if settingsJson["servername"].(string) != "" {
				if settingsJson["ownerid"].(string) != "" {
					// error handling and user communication
					_, err = r.Context().Value(sys.EntClientKey).(*ent.Client).Settings.Create().SetWordfilter(false).
						SetTwitterannounce(false).
						SetTwitchannounce(false).
						SetStatsprivate(true).
						SetStatspagemode("default").
						SetStatspage(false).
						SetSpamprotection(false).
						SetSpamchannel("general").
						SetServername(settingsJson["servername"].(string)).
						SetServerid(settingsJson["serverid"].(string)).
						SetPermtoken("test").
						SetOwnerid(settingsJson["ownerid"].(string)).
						SetMusic(false).
						SetModeration(false).
						SetLoggerchannel("general").
						SetLogger(false).
						SetLinkprotection(false).
						SetGreetings(false).
						SetGreetermode("image").
						SetGreeterchannel("general").
						SetAutomatedmoderation(false).
						SetApitoken("n/a").
						SetApitoggle(false).
						Save(r.Context().Value(sys.ContextClientKey).(context.Context))

					if err != nil {
						sys.ErrorJsonResponse(w, "data_could_not_be_added_to_database", errors.New("inserting settings into database failed"))
					}

					// Send message to the user if transaction could be made
					// in this case only usefull for the bot but may be implemented to the webpage once stable implementation exists
					logger.Logtodb([]string{"system", "settings for server" + settingsJson["serverid"].(string) + " was have been created", "settingscreate", settingsJson["serverid"].(string)}, r.Context().Value(sys.EntClientKey).(*ent.Client), r.Context().Value(sys.ContextClientKey).(context.Context))
					w.Write([]byte(`{"type":"success", "code":"data_was_put_into_the_database"}`))

				} else {
					sys.ErrorJsonResponse(w, "missing_parameter", errors.New("ownerid needs to be set"))
				}
			} else {
				sys.ErrorJsonResponse(w, "missing_parameter", errors.New("servername needs to be set"))
			}
		} else {
			sys.ErrorJsonResponse(w, "missing_parameter", errors.New("serverid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "mssing_parameter", errors.New("commiterid needs to be set"))
	}
}

func updateServerSettings(w http.ResponseWriter, r *http.Request) {
	// fetch data
	settingsJson := make(map[string]any)
	settingsData, err := ioutil.ReadAll(r.Body)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_find_data_in_request", errors.New("request body seems to be empty"))
	}

	// process data
	err = json.Unmarshal(settingsData, &settingsJson)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_proccess_data", errors.New("request data could not be proccessed"))
	}

	fmt.Println(settingsJson)

	if commiteridStr, ok := settingsJson["commiterid"].(string); ok {
		fmt.Println(0)
		if serveridStr, ok := settingsJson["serverid"].(string); ok {
			fmt.Println(1)
			if blacklistBool, ok := settingsJson["blacklist"].(bool); ok {
				fmt.Println(2)
				if twitchannounceBool, ok := settingsJson["twitchannounce"].(bool); ok {
					fmt.Println(3)
					if twitterannounceBool, ok := settingsJson["twitteranounce"].(bool); ok {
						fmt.Println(4)
						if statsprivateBool, ok := settingsJson["statsprivate"].(bool); ok {
							fmt.Println(5)
							if statspagemodeStr, ok := settingsJson["statspagemode"].(string); ok {
								fmt.Println(6)
								if statspageBool, ok := settingsJson["statspage"].(bool); ok {
									fmt.Println(7)
									if spamprotectBool, ok := settingsJson["spamprotect"].(bool); ok {
										fmt.Println(8)
										if spamchannelStr, ok := settingsJson["spamchannel"].(string); ok {
											fmt.Println(9)
											if servernameStr, ok := settingsJson["servername"].(string); ok {
												fmt.Println(10)
												if musicBool, ok := settingsJson["music"].(bool); ok {
													fmt.Println(11)
													if moderationBool, ok := settingsJson["moderation"].(bool); ok {
														fmt.Println(12)
														if loggerchannelStr, ok := settingsJson["loggerchannel"].(string); ok {
															fmt.Println(13)
															if loggerBool, ok := settingsJson["logger"].(bool); ok {
																fmt.Println(14)
																if linkprotectBool, ok := settingsJson["linkprotect"].(bool); ok {
																	fmt.Println(15)
																	if helloBool, ok := settingsJson["greetings"].(bool); ok {
																		fmt.Println(16)
																		if greetingstypeStr, ok := settingsJson["greetingtype"].(string); ok {
																			fmt.Println(17)
																			if greetingschannelStr, ok := settingsJson["greetingchannel"].(string); ok {
																				fmt.Println(18)
																				if automodBool, ok := settingsJson["automod"].(bool); ok {
																					fmt.Println(19)
																					if apiBool, ok := settingsJson["apitoggle"].(bool); ok {
																						fmt.Println(20)
																						if statsBool, ok := settingsJson["stats"].(bool); ok {
																							fmt.Println(21)
																							if anounceChannelStr, ok := settingsJson["announcechannel"].(string); ok {
																								fmt.Println(21)

																								fmt.Println(spamprotectBool)
																								fmt.Println(linkprotectBool)
																								fmt.Println(blacklistBool)
																								fmt.Println(apiBool)

																								_, err := r.Context().Value(sys.EntClientKey).(*ent.Client).Settings.Update().
																									Where(settings.Serverid(serveridStr)).
																									SetWordfilter(blacklistBool).
																									SetTwitterannounce(twitterannounceBool).
																									SetTwitchannounce(twitchannounceBool).
																									SetStatsprivate(statsprivateBool).
																									SetStatspagemode(statspagemodeStr).
																									SetStatspage(statspageBool).
																									SetSpamprotection(spamprotectBool).
																									SetSpamchannel(spamchannelStr).
																									SetServername(servernameStr).
																									SetMusic(musicBool).
																									SetModeration(moderationBool).
																									SetLoggerchannel(loggerchannelStr).
																									SetLogger(loggerBool).
																									SetLinkprotection(linkprotectBool).
																									SetGreetings(helloBool).
																									SetGreetermode(greetingstypeStr).
																									SetGreeterchannel(greetingschannelStr).
																									SetAutomatedmoderation(automodBool).
																									SetApitoggle(apiBool).
																									SetStats(statsBool).
																									SetAnnouncechannel(anounceChannelStr).
																									Save(r.Context().Value(sys.ContextClientKey).(context.Context))
																								if err != nil {
																									fmt.Println(err)
																									http.Error(w, `{"type":"error", "code":"could_update_database"}`, http.StatusInternalServerError)
																									return
																								}

																								logger.Logtodb([]string{commiteridStr, "settings for server: " + serveridStr + " was changed by: " + commiteridStr, "settingschange", serveridStr}, r.Context().Value(sys.EntClientKey).(*ent.Client), r.Context().Value(sys.ContextClientKey).(context.Context))
																								w.Write([]byte(`{"type":"success", "code":"data_was_updated_in_the_database"}`))
																							} else {
																								sys.ErrorJsonResponse(w, "missing_parameter", errors.New("announcechannel needs to be set"))
																							}
																						} else {
																							sys.ErrorJsonResponse(w, "missing_parameter", errors.New("stats needs to be set"))
																						}
																					} else {
																						sys.ErrorJsonResponse(w, "missing_parameter", errors.New("apitoggle needs to be set"))
																					}
																				} else {
																					sys.ErrorJsonResponse(w, "missing_parameter", errors.New("automod needs to be set"))
																				}
																			} else {
																				sys.ErrorJsonResponse(w, "missing_parameter", errors.New("greetingchannel needs to be set"))
																			}
																		} else {
																			sys.ErrorJsonResponse(w, "missing_parameter", errors.New("greetingtype needs to be set"))
																		}
																	} else {
																		sys.ErrorJsonResponse(w, "missing_parameter", errors.New("greetings needs to be set"))
																	}
																} else {
																	sys.ErrorJsonResponse(w, "missing_parameter", errors.New("linkprotect needs to be set"))
																}
															} else {
																sys.ErrorJsonResponse(w, "missing_parameter", errors.New("logger needs to be set"))
															}
														} else {
															sys.ErrorJsonResponse(w, "missing_parameter", errors.New("loggerchannel needs to be set"))
														}
													} else {
														sys.ErrorJsonResponse(w, "missing_parameter", errors.New("moderation needs to be set"))
													}
												} else {
													sys.ErrorJsonResponse(w, "missing_parameter", errors.New("music needs to be set"))
												}
											} else {
												sys.ErrorJsonResponse(w, "missing_parameter", errors.New("servername needs to be set"))
											}
										} else {
											sys.ErrorJsonResponse(w, "missing_parameter", errors.New("spamchannel needs to be set"))
										}
									} else {
										sys.ErrorJsonResponse(w, "missing_parameter", errors.New("spamprotect needs to be set"))
									}
								} else {
									sys.ErrorJsonResponse(w, "missing_parameter", errors.New("statspage needs to be set"))
								}
							} else {
								sys.ErrorJsonResponse(w, "missing_parameter", errors.New("statspagemode needs to be set"))
							}
						} else {
							sys.ErrorJsonResponse(w, "missing_parameter", errors.New("statsprivate needs to be set"))
						}
					} else {
						sys.ErrorJsonResponse(w, "missing_parameter", errors.New("twitchannounce needs to be set"))
					}
				} else {
					sys.ErrorJsonResponse(w, "missing_parameter", errors.New("twitteranounce needs to be set"))
				}
			} else {
				sys.ErrorJsonResponse(w, "missing_parameter", errors.New("blacklist needs to be set"))
			}
		} else {
			sys.ErrorJsonResponse(w, "missing_parameter", errors.New("serverid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_parameter", errors.New("commiterid needs to be set"))
	}
}

func getServerSettings(w http.ResponseWriter, r *http.Request) {
	settingsQuery := r.URL.Query()

	if settingsQuery.Get("commiterid") != "" {
		if settingsQuery.Get("serverid") != "" {
			// replace with actual api data
			user, err := r.Context().Value(sys.EntClientKey).(*ent.Client).Settings.Query().Where(settings.Serverid(settingsQuery.Get("serverid"))).All(r.Context().Value(sys.ContextClientKey).(context.Context))
			if err != nil {
				sys.ErrorJsonResponse(w, "could_not_get_user", errors.New("the requested user was not found"))
			}

			sys.SuccessJsonResponse(w, user)
		} else {
			sys.ErrorJsonResponse(w, "missing_parameter", errors.New("serverid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_parameter", errors.New("commiterid needs to be set"))
	}
}

func createSocial(w http.ResponseWriter, r *http.Request) {
	// fetch data
	settingsJson := make(map[string]any)
	settingsData, err := ioutil.ReadAll(r.Body)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_find_data_in_request", errors.New("could not find data in that request"))
	}

	// process data
	err = json.Unmarshal(settingsData, &settingsJson)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_proccess_data", errors.New("request data could not be proccessed"))
	}
	if settingsJson["commiterid"].(string) != "" {
		if settingsJson["serverid"].(string) != "" {
			if settingsJson["identifier"].(string) != "" {
				if settingsJson["type"].(string) != "" {

					r.Context().Value(sys.EntClientKey).(*ent.Client).Socialmedia.Create().
						SetServerid(settingsJson["serverid"].(string)).
						SetIdentificator(settingsJson["identifier"].(string)).
						SetType(settingsJson["type"].(string)).
						Save(r.Context().Value(sys.ContextClientKey).(context.Context))

					logger.Logtodb([]string{settingsJson["commiterid"].(string), "socialmedia entry for server" + settingsJson["serverid"].(string) + " was added by" + settingsJson["commiterid"].(string), "socialcreate", settingsJson["serverid"].(string)}, r.Context().Value(sys.EntClientKey).(*ent.Client), r.Context().Value(sys.ContextClientKey).(context.Context))
					w.Write([]byte(`{"type":"success", "code":"data_was_put_into_the_database"}`))

				} else {
					sys.ErrorJsonResponse(w, "missing_parameter", errors.New("type needs to be set"))
				}
			} else {
				sys.ErrorJsonResponse(w, "missing_parameter", errors.New("identifier needs to be set"))
			}
		} else {
			sys.ErrorJsonResponse(w, "missing_parameter", errors.New("serverid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_parameter", errors.New("commiterid needs to be set"))
	}
}

/* ========================================================
todo: update all below todo comments asap
======================================================== */

// @TODO: actually updating the database
func updateSocial(w http.ResponseWriter, r *http.Request) {
	// fetch data
	settingsJson := make(map[string]any)
	settingsData, err := ioutil.ReadAll(r.Body)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_find_data_in_request", errors.New("could not find data in that request"))
	}

	// process data
	err = json.Unmarshal(settingsData, &settingsJson)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_proccess_data", errors.New("request data could not be proccessed"))
	}

	if settingsJson["commiterid"].(string) != "" {
		if settingsJson["serverid"].(string) != "" {
			if settingsJson["identifier"].(string) != "" {
				if settingsJson["type"].(string) != "" {

					_, err = r.Context().Value(sys.EntClientKey).(*ent.Client).Socialmedia.Update().
						SetServerid(settingsJson["serverid"].(string)).
						SetIdentificator(settingsJson["identifier"].(string)).
						SetType(settingsJson["type"].(string)).
						Save(r.Context().Value(sys.ContextClientKey).(context.Context))
					if err != nil {
						sys.ErrorJsonResponse(w, "database_error", errors.New("could not update the database"))
					}

					logger.Logtodb([]string{settingsJson["commiterid"].(string), "socialmedia entry for server" + settingsJson["serverid"].(string) + " was updated by" + settingsJson["commiterid"].(string), "socialupdate", settingsJson["serverid"].(string)}, r.Context().Value(sys.EntClientKey).(*ent.Client), r.Context().Value(sys.ContextClientKey).(context.Context))
					w.Write([]byte(`{"type":"success", "code":"data_was_put_into_the_database"}`))

				}
			}
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_parameter", errors.New("commiterid needs to be set"))
	}
}

// @TODO fetch parameters from request query
func deleteSocial(w http.ResponseWriter, r *http.Request) {

	if r.URL.Query().Get("commiterid") != "" {
		if r.URL.Query().Get("serverid") != "" {
			if r.URL.Query().Get("identifier") != "" {

				_, err := r.Context().Value(sys.EntClientKey).(*ent.Client).Socialmedia.Delete().
					Where(socialmedia.Serverid(r.URL.Query().Get("serverid")), socialmedia.Identificator(r.URL.Query().Get("identifier"))).
					Exec(r.Context().Value(sys.ContextClientKey).(context.Context))

				if err != nil {
					sys.ErrorJsonResponse(w, "data_could_not_be_deleted", errors.New("the data requested could not be removed"))
				}

				w.Write([]byte(`{"type":"success", "code":"data_was_removed_successfully"}`))

			} else {
				sys.ErrorJsonResponse(w, "missing_parameter", errors.New("identifier needs to be set"))
			}
		} else {
			sys.ErrorJsonResponse(w, "missing_parameter", errors.New("serverid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_parameter", errors.New("commiterid needs to be set"))
	}
}

// @TODO user userdata to manipulate the db query
func getSocial(w http.ResponseWriter, r *http.Request) {
	userData := r.URL.Query()
	fmt.Println(userData)

	if userData.Get("commiterid") != "" {
		if userData.Get("serverid") != "" {
			if userData.Get("identifer") != "" {

				// replace with actual api data
				social, err := r.Context().Value(sys.EntClientKey).(*ent.Client).Socialmedia.Query().
					Where(socialmedia.Serverid(userData.Get("serverid")), socialmedia.Identificator(userData.Get("identifer"))).All(r.Context().Value(sys.ContextClientKey).(context.Context))
				if err != nil {
					sys.ErrorJsonResponse(w, "could_not_get_user", errors.New("could not get the requested user object"))
				}
				sys.SuccessJsonResponse(w, social)

			} else {
				sys.ErrorJsonResponse(w, "missing_parameter", errors.New("identifier needs to be set"))
			}
		} else {
			sys.ErrorJsonResponse(w, "missing_parameter", errors.New("serverid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_parameter", errors.New("commiterid needs to be set"))
	}
}