package application

import (
	"context"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
	"net/http"
	"sort"
	"time"

	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
	"git.coopgo.io/coopgo-platform/fleets/storage"
	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
	groupstorage "git.coopgo.io/coopgo-platform/groups-management/storage"
	accounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	mobilityaccountsstorage "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
	"github.com/google/uuid"
	"github.com/gorilla/mux"
	"google.golang.org/protobuf/types/known/structpb"
)

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

	accounts, err := h.services.GetAccounts()
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	beneficiaries, err := h.services.GetBeneficiaries()
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	bookings, err := h.services.GetBookings()
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	request := &groupsmanagement.GetGroupsRequest{
		Namespaces: []string{"parcoursmob_organizations"},
	}

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

	var groups = []groupstorage.Group{}

	for _, group := range resp.Groups {
		g := group.ToStorageType()
		groups = append(groups, g)
	}

	sort.Sort(sorting.GroupsByName(groups))

	h.Renderer.Administration(w, r, accounts, beneficiaries, groups, bookings)
}

func (h *ApplicationHandler) AdministrationCreateGroup(w http.ResponseWriter, r *http.Request) {
	if r.Method == "POST" {
		r.ParseForm()

		if r.FormValue("name") == "" {

			fmt.Println("invalid name")
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		modules := map[string]any{
			"beneficiaries":       r.FormValue("modules.beneficiaries") == "on",
			"journeys":            r.FormValue("modules.journeys") == "on",
			"vehicles":            r.FormValue("modules.vehicles") == "on",
			"vehicles_management": r.FormValue("modules.vehicles_management") == "on",
			"events":              r.FormValue("modules.events") == "on",
			"agenda":              r.FormValue("modules.agenda") == "on",
			"groups":              r.FormValue("modules.groups") == "on",
			"administration":      r.FormValue("modules.administration") == "on",
			"support":             r.FormValue("modules.support") == "on",
			"group_module":        r.FormValue("modules.group_module") == "on",
		}

		groupid := uuid.NewString()

		dataMap := map[string]any{
			"name":    r.FormValue("name"),
			"modules": modules,
		}

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

		request_organization := &groupsmanagement.AddGroupRequest{
			Group: &groupsmanagement.Group{
				Id:        groupid,
				Namespace: "parcoursmob_organizations",
				Data:      data.GetStructValue(),
			},
		}

		request_role := &groupsmanagement.AddGroupRequest{
			Group: &groupsmanagement.Group{
				Id:        groupid + ":admin",
				Namespace: "parcoursmob_roles",
			},
		}

		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_organization)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		// Create the admin role for the organization
		_, err = h.services.GRPC.GroupsManagement.AddGroup(context.TODO(), request_role)
		if err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
		return
	}
	h.Renderer.AdministrationCreateGroup(w, r)
}

func (h *ApplicationHandler) AdministrationGroupDisplay(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	groupid := vars["groupid"]

	request := &groupsmanagement.GetGroupRequest{
		Id: groupid,
	}

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

	groupmembers, admins, err := h.groupmembers(groupid)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	h.Renderer.AdministrationGroupDisplay(w, r, resp.Group.ToStorageType(), groupmembers, admins)
}

func (h *ApplicationHandler) AdministrationGroupInviteAdmin(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	groupid := vars["groupid"]

	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
		Id:        groupid,
		Namespace: "parcoursmob_organizations",
	})

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

	r.ParseForm()

	accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
		Username:  r.FormValue("username"),
		Namespace: "parcoursmob",
	})

	if err == nil {
		// Account already exists : adding the existing account to admin list
		account := accountresp.Account.ToStorageType()
		account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid)
		account.Data["groups"] = append(account.Data["groups"].([]any), groupid, groupid+":admin")

		as, _ := accounts.AccountFromStorageType(&account)

		_, err = h.services.GRPC.MobilityAccounts.UpdateData(
			context.TODO(),
			&accounts.UpdateDataRequest{
				Account: as,
			},
		)

		fmt.Println(err)

		data := map[string]any{
			"group": groupresp.Group.ToStorageType().Data["name"],
		}

		if err := h.emailing.Send("onboarding.existing_administrator", r.FormValue("username"), data); err != nil {
			fmt.Println(err)
		}

		http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
		return
	} else {
		// Onboard now administrator
		onboarding := map[string]any{
			"username": r.FormValue("username"),
			"group":    groupid,
			"admin":    true,
		}

		b := make([]byte, 16)
		if _, err := io.ReadFull(rand.Reader, b); err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		key := base64.RawURLEncoding.EncodeToString(b)

		h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL

		data := map[string]any{
			"group": groupresp.Group.ToStorageType().Data["name"],
			"key":   key,
		}

		if err := h.emailing.Send("onboarding.new_administrator", r.FormValue("username"), data); err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
	}

	http.Redirect(w, r, fmt.Sprintf("/app/administration/groups/%s", groupid), http.StatusFound)
	return
}

func (h *ApplicationHandler) AdministrationGroupInviteMember(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	groupid := vars["groupid"]

	groupresp, err := h.services.GRPC.GroupsManagement.GetGroup(context.TODO(), &groupsmanagement.GetGroupRequest{
		Id:        groupid,
		Namespace: "parcoursmob_organizations",
	})

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

	group := groupresp.Group.ToStorageType()

	r.ParseForm()

	accountresp, err := h.services.GRPC.MobilityAccounts.GetAccountUsername(context.TODO(), &accounts.GetAccountUsernameRequest{
		Username:  r.FormValue("username"),
		Namespace: "parcoursmob",
	})

	if err == nil {
		account := accountresp.Account.ToStorageType()
		account.Data["groups"] = append(account.Data["groups"].([]any), group.ID)

		as, _ := accounts.AccountFromStorageType(&account)

		_, err = h.services.GRPC.MobilityAccounts.UpdateData(
			context.TODO(),
			&accounts.UpdateDataRequest{
				Account: as,
			},
		)

		fmt.Println(err)

		data := map[string]any{
			"group": group.Data["name"],
		}

		if err := h.emailing.Send("onboarding.existing_member", r.FormValue("username"), data); err != nil {
			fmt.Println(err)
		}

		http.Redirect(w, r, "/app/group/settings", http.StatusFound)
		return
	} else {
		// Onboard now administrator
		onboarding := map[string]any{
			"username": r.FormValue("username"),
			"group":    group.ID,
			"admin":    false,
		}

		b := make([]byte, 16)
		if _, err := io.ReadFull(rand.Reader, b); err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		key := base64.RawURLEncoding.EncodeToString(b)

		h.cache.PutWithTTL("onboarding/"+key, onboarding, 168*time.Hour) // 1 week TTL

		data := map[string]any{
			"group": group.Data["name"],
			"key":   key,
		}

		if err := h.emailing.Send("onboarding.new_member", r.FormValue("username"), data); err != nil {
			fmt.Println(err)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
	}

	http.Redirect(w, r, "/app/administration/groups/"+group.ID, http.StatusFound)
	return
}

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

	request := &fleets.GetBookingsRequest{}
	resp, err := h.services.GRPC.Fleets.GetBookings(context.TODO(), request)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusNotFound)
		return
	}

	bookings := []storage.Booking{}

	for _, b := range resp.Bookings {
		booking := b.ToStorageType()
		bookings = append(bookings, booking)
	}

	sort.Sort(sorting.BookingsByStartdate(bookings))

	vehicles, _ := h.services.GetVehiclesMap()
	groups, _ := h.services.GetGroupsMap()

	h.Renderer.VehicleBookingsList(w, r, bookings, vehicles, groups)
}

func (h *ApplicationHandler) members() ([]*accounts.Account, error) {
	resp, err := h.services.GRPC.MobilityAccounts.GetAccounts(context.TODO(), &accounts.GetAccountsRequest{
		Namespaces: []string{"parcoursmob"},
	})
	if err != nil {
		return nil, err
	}

	return resp.Accounts, nil
}

func (h *ApplicationHandler) groupmembers(groupid string) (groupmembers []mobilityaccountsstorage.Account, admins []mobilityaccountsstorage.Account, err error) {
	members, err := h.members()
	if err != nil {
		if err != nil {
			fmt.Println(err)
			return nil, nil, err
		}
	}

	groupmembers = []mobilityaccountsstorage.Account{}
	admins = []mobilityaccountsstorage.Account{}

	for _, m := range members {
		mm := m.ToStorageType()
		for _, g := range mm.Data["groups"].([]any) {
			if g.(string) == groupid {
				groupmembers = append(groupmembers, mm)
			}
			if g.(string) == groupid+":admin" {
				admins = append(admins, mm)
			}
		}
	}

	return groupmembers, admins, err
}