package application

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"strings"

	formvalidators "git.coopgo.io/coopgo-apps/parcoursmob/utils/form-validators"
	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	"google.golang.org/protobuf/types/known/structpb"
)

type UserForm struct {
	FirstName   string `json:"first_name" validate:"required"`
	LastName    string `json:"last_name" validate:"required"`
	Email       string `json:"email" validate:"required,email"`
	PhoneNumber string `json:"phone_number" validate:"required,phoneNumber"`
	Address     any    `json:"address,omitempty"`
	Gender      string `json:"gender"`
}

func (h *ApplicationHandler) MemberDisplay(w http.ResponseWriter, r *http.Request) {

	adm := strings.Split(r.URL.Path, "/")
	adminid := adm[3]

	request := &mobilityaccounts.GetAccountRequest{
		Id: adminid,
	}

	resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	h.Renderer.MemberDisplay(w, r, resp.Account.ToStorageType())
}

func (h *ApplicationHandler) MemberUpdate(w http.ResponseWriter, r *http.Request) {
	adm := strings.Split(r.URL.Path, "/")
	userID := adm[3]

	if r.Method == "POST" {

		dataMap, err := parseUserForm(r)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		data, err := structpb.NewValue(dataMap)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		request := &mobilityaccounts.UpdateDataRequest{
			Account: &mobilityaccounts.Account{
				Id:        userID,
				Namespace: "parcoursmob",
				Data:      data.GetStructValue(),
			},
		}

		resp, err := h.services.GRPC.MobilityAccounts.UpdateData(context.TODO(), request)

		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, fmt.Sprintf("/app/members/%s", resp.Account.Id), http.StatusFound)

		return
	}

	request := &mobilityaccounts.GetAccountRequest{
		Id: userID,
	}

	resp, err := h.services.GRPC.MobilityAccounts.GetAccount(context.TODO(), request)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	h.Renderer.MemberUpdate(w, r, resp.Account.ToStorageType())
}

func parseUserForm(r *http.Request) (map[string]any, error) {
	if err := r.ParseForm(); err != nil {
		return nil, err
	}

	formData := UserForm{
		FirstName:   r.PostFormValue("first_name"),
		LastName:    r.PostFormValue("last_name"),
		Email:       r.PostFormValue("email"),
		PhoneNumber: r.PostFormValue("phone_number"),
		Gender:      r.PostFormValue("gender"),
	}

	validate := formvalidators.New()
	if err := validate.Struct(formData); err != nil {
		return nil, err
	}

	d, err := json.Marshal(formData)
	if err != nil {
		return nil, err
	}

	var dataMap map[string]any
	err = json.Unmarshal(d, &dataMap)
	if err != nil {
		return nil, err
	}

	return dataMap, nil
}