package support

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

	"github.com/FrankenBotDev/FrankenAPI/ent"
	"github.com/FrankenBotDev/FrankenAPI/ent/support"
	"github.com/FrankenBotDev/FrankenAPI/ent/supportresponse"
	"github.com/FrankenBotDev/FrankenAPI/pkg/routes/logger"
	"github.com/FrankenBotDev/FrankenAPI/pkg/sys"
	"github.com/go-chi/chi/v5"
)

// TODO: error handle route properly
func SupportRouter() http.Handler {
	r := chi.NewRouter()

	r.Get("/", getTicket)
	r.Get("/search", getTicketByID)
	r.Post("/", openTicket)
	r.Put("/", updateTicket)
	r.Delete("/", deleteTicket)
	r.Post("/message", writetMessage)
	r.Get("/message", getMessages)
	r.Get("/message/unread", getUnreadMessages)
	return r
}

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

	if ticketQuery.Get("serverid") != "" {
		ticket, err := r.Context().Value(sys.EntClientKey).(*ent.Client).Support.Query().
			Where(support.Serverid(ticketQuery.Get("serverid")), support.Not(support.Status("closed"))).
			All(r.Context().Value(sys.ContextClientKey).(context.Context))
		if err != nil {
			sys.ErrorJsonResponse(w, "could_not_get_user", errors.New("requested user could not be fetched from the database"))
		}

		sys.SuccessJsonResponse(w, ticket)
	} else {
		sys.ErrorJsonResponse(w, "missing_param", errors.New("serverid needs to be set"))
	}
}

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

	if ticketQuery.Get("serverid") != "" {
		if ticketQuery.Get("refid") != "" {

			// replace with actual api data
			ticket, err := r.Context().Value(sys.EntClientKey).(*ent.Client).Support.Query().
				Where(support.Serverid(ticketQuery.Get("serverid")), support.Refid(ticketQuery.Get("refid"))).
				All(r.Context().Value(sys.ContextClientKey).(context.Context))
			if err != nil {
				sys.ErrorJsonResponse(w, "could_not_get_user", errors.New("requested user could not be fetched from the database"))
			}

			sys.SuccessJsonResponse(w, ticket)

		} else {
			sys.ErrorJsonResponse(w, "missing_param", errors.New("refid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_param", errors.New("serverid needs to be set"))
	}
}

func openTicket(w http.ResponseWriter, r *http.Request) {
	// daten fetchen
	ticketData, err := ioutil.ReadAll(r.Body)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_find_data_in_request", errors.New("the request appears to be empty"))
	}

	// proccess data
	ticketJson := make(map[string]any)
	err = json.Unmarshal(ticketData, &ticketJson)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_proccess_data", errors.New("request data could not be proccessed"))
	}

	devRefid := sys.RandStringRunes(16)

	if serveridStr, ok := ticketJson["serverid"].(string); ok {
		if devRefid != "" {
			if titleStr, ok := ticketJson["title"].(string); ok {
				if descStr, ok := ticketJson["description"].(string); ok {
					if creatorStr, ok := ticketJson["creator"].(string); ok {
						// replace with actual api data
						err := r.Context().Value(sys.EntClientKey).(*ent.Client).Support.Create().
							SetServerid(serveridStr).
							SetRefid(devRefid).
							SetStatus("open").
							SetTitle(titleStr).
							SetDescription(descStr).
							SetCreator(creatorStr).
							Exec(r.Context().Value(sys.ContextClientKey).(context.Context))
						if err != nil {
							sys.ErrorJsonResponse(w, "could_not_get_user", errors.New("requested user could not be fetched from the database"))
						}

						logger.Logtodb([]string{
							creatorStr,
							"Opened Support Ticket with RefiD: " + devRefid,
							"Support Ticket Open",
							serveridStr,
						}, r.Context().Value(sys.EntClientKey).(*ent.Client), r.Context().Value(sys.ContextClientKey).(context.Context))

						sys.SuccessJsonResponse(w, "ticket_created")
					}
				}
			}
		}
	}
}

func updateTicket(w http.ResponseWriter, r *http.Request) {
	// daten fetchen
	ticketData, err := ioutil.ReadAll(r.Body)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_find_data_in_request", errors.New("the request appears to be empty"))
	}

	// proccess data
	ticketJson := make(map[string]any)
	err = json.Unmarshal(ticketData, &ticketJson)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_proccess_data", errors.New("request data could not be proccessed"))
	}

	fmt.Println(ticketJson)

	if commiteridStr, ok := ticketJson["commiterid"].(string); ok {
		fmt.Println(0)
		if serveridStr, ok := ticketJson["serverid"].(string); ok {
			fmt.Println(1)
			if refidStr, ok := ticketJson["refid"].(string); ok {
				fmt.Println(2)
				if statusStr, ok := ticketJson["status"].(string); ok {
					fmt.Println(3)
					if titleStr, ok := ticketJson["title"].(string); ok {
						fmt.Println(4)
						if descStr, ok := ticketJson["description"].(string); ok {
							fmt.Println(5)
							if creatorStr, ok := ticketJson["creator"].(string); ok {
								fmt.Println(6)
								// replace with actual api data
								err := r.Context().Value(sys.EntClientKey).(*ent.Client).Support.Update().
									Where(support.Refid(refidStr), support.Serverid(serveridStr)).
									SetServerid(serveridStr).
									SetRefid(refidStr).
									SetStatus(statusStr).
									SetTitle(titleStr).
									SetDescription(descStr).
									SetCreator(creatorStr).
									Exec(r.Context().Value(sys.ContextClientKey).(context.Context))
								if err != nil {
									sys.ErrorJsonResponse(w, "could_not_get_user", errors.New("requested user could not be fetched from the database"))
								}

								logger.Logtodb([]string{
									commiteridStr,
									"Updated Support Ticket with RefiD: " + refidStr,
									"Support Ticket Update",
									serveridStr,
								}, r.Context().Value(sys.EntClientKey).(*ent.Client), r.Context().Value(sys.ContextClientKey).(context.Context))
								sys.SuccessJsonResponse(w, "ticket_created")
							}
						}
					}
				}
			}
		}
	}
}

func deleteTicket(w http.ResponseWriter, r *http.Request) {
	// daten fetchen
	ticketData, err := ioutil.ReadAll(r.Body)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_find_data_in_request", errors.New("the request appears to be empty"))
	}

	// proccess data
	ticketJson := make(map[string]any)
	err = json.Unmarshal(ticketData, &ticketJson)
	if err != nil {
		sys.ErrorJsonResponse(w, "could_not_proccess_data", errors.New("request data could not be proccessed"))
	}

	if commiteridStr, ok := ticketJson["commiterid"].(string); ok {
		if serveridStr, ok := ticketJson["serverid"].(string); ok {
			if refidStr, ok := ticketJson["refid"].(string); ok {
				// replace with actual api data
				_, err := r.Context().Value(sys.EntClientKey).(*ent.Client).Support.Delete().
					Where(support.Serverid(serveridStr), support.Refid(refidStr)).
					Exec(r.Context().Value(sys.ContextClientKey).(context.Context))
				if err != nil {
					sys.ErrorJsonResponse(w, "could_not_get_user", errors.New("requested user could not be fetched from the database"))
				}

				logger.Logtodb([]string{
					commiteridStr,
					"Removed Support Ticket with RefiD: " + refidStr,
					"Support Ticket Remove",
					serveridStr,
				}, r.Context().Value(sys.EntClientKey).(*ent.Client), r.Context().Value(sys.ContextClientKey).(context.Context))
				sys.SuccessJsonResponse(w, "ticket_created")

				sys.SuccessJsonResponse(w, "ticket_created")
			}
		}
	}
}

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

	if tickerResponseQuery.Get("refid") != "" {
		if tickerResponseQuery.Get("commiterid") != "" {
			replies, err := r.Context().Value(sys.EntClientKey).(*ent.Client).SupportResponse.Query().
				Where(supportresponse.Refid(tickerResponseQuery.Get("refid"))).
				All(r.Context().Value(sys.ContextClientKey).(context.Context))

			if err != nil {
				sys.ErrorJsonResponse(w, "database_error", errors.New("could not get responses from database"))
			}

			sys.SuccessJsonResponse(w, replies)
		} else {
			sys.ErrorJsonResponse(w, "missing_params", errors.New("commiterid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_params", errors.New("refid needs to be set"))
	}
}

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

	if tickerResponseQuery.Get("refid") != "" {
		if tickerResponseQuery.Get("commiterid") != "" {
			replies, err := r.Context().Value(sys.EntClientKey).(*ent.Client).SupportResponse.Query().
				Where(supportresponse.Refid(tickerResponseQuery.Get("refid")), supportresponse.Not(supportresponse.Isread(false))).
				All(r.Context().Value(sys.ContextClientKey).(context.Context))

			if err != nil {
				sys.ErrorJsonResponse(w, "database_error", errors.New("could not get responses from database"))
			}

			sys.SuccessJsonResponse(w, replies)
		} else {
			sys.ErrorJsonResponse(w, "missing_params", errors.New("commiterid needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_params", errors.New("refid needs to be set"))
	}
}

func writetMessage(w http.ResponseWriter, r *http.Request) {
	// fetch data
	ticketResponseJson := make(map[string]any)
	ticketResponseData, err := ioutil.ReadAll(r.Body)
	if err != nil {
		http.Error(w, `"type":"error", "code":"could_not_find_data_in_request"`, http.StatusInternalServerError)
		return
	}

	// process data
	err = json.Unmarshal(ticketResponseData, &ticketResponseJson)
	if err != nil {
		http.Error(w, `{"type":"error", "code":"could_not_proccess_data"}`, http.StatusInternalServerError)
		return
	}
	if refidStr, ok := ticketResponseJson["refid"].(string); ok {
		fmt.Println(0)
		if messageStr, ok := ticketResponseJson["message"].(string); ok {
			fmt.Println(1)
			if rtcChannelStr, ok := ticketResponseJson["rtcchannel"].(string); ok {
				fmt.Println(2)
				if writerStr, ok := ticketResponseJson["writer"].(string); ok {
					fmt.Println(3)
					if isReadBool, ok := ticketResponseJson["isread"].(bool); ok {
						fmt.Println(4)
						if typeStr, ok := ticketResponseJson["type"].(string); ok {
							fmt.Println(5)
							err := r.Context().Value(sys.EntClientKey).(*ent.Client).SupportResponse.Create().
								SetRefid(refidStr).
								SetMessage(messageStr).
								SetRtcchannel(rtcChannelStr).
								SetWriter(writerStr).
								SetIsread(isReadBool).
								SetType(typeStr).
								SetCreated(time.Now()).
								Exec(r.Context().Value(sys.ContextClientKey).(context.Context))

							if err != nil {
								fmt.Println(err)
								sys.ErrorJsonResponse(w, "database_error", errors.New("could not post to database"))
							}
						} else {
							sys.ErrorJsonResponse(w, "missing_param", errors.New("type needs to be set"))
						}
					} else {
						sys.ErrorJsonResponse(w, "missing_param", errors.New("isread needs to be set"))
					}
				} else {
					sys.ErrorJsonResponse(w, "missing_param", errors.New("writer need sto e set"))
				}
			} else {
				sys.ErrorJsonResponse(w, "missing_param", errors.New("rtcchannel needs to be set"))
			}
		} else {
			sys.ErrorJsonResponse(w, "missing_param", errors.New("message needs to be set"))
		}
	} else {
		sys.ErrorJsonResponse(w, "missing_param", errors.New("refid needs to be set"))
	}
}

/* =====================================================
Websocket Code
===================================================== */
// TODO: move code to this route