package application

import (
	"context"
	"fmt"
	"net/http"
	"sort"

	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
	"git.coopgo.io/coopgo-apps/parcoursmob/utils/sorting"
	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
	agendastorage "git.coopgo.io/coopgo-platform/agenda/storage"
	"git.coopgo.io/coopgo-platform/groups-management/storage"
	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	"google.golang.org/protobuf/types/known/timestamppb"
)

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

	g := r.Context().Value(identification.GroupKey)
	if g == nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	group := g.(storage.Group)

	request := &mobilityaccounts.GetAccountsBatchRequest{
		Accountids: group.Members,
	}

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

	var accounts = []any{}

	// We only display the 10 last here
	count := len(resp.Accounts)
	min := count - 5
	if min < 0 {
		min = 0
	}

	for _, account := range resp.Accounts[min:] {
		if filterAccount(r, account) {
			a := account.ToStorageType()
			accounts = append([]any{a}, accounts...)
		}
	}

	members, _, err := h.groupmembers(group.ID)
	if err != nil {
		fmt.Println(err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	count_members := len(members)

	events := []agendastorage.Event{}

	eventsresp, err := h.services.GRPC.Agenda.GetEvents(context.TODO(), &agenda.GetEventsRequest{
		Namespaces: []string{"parcoursmob_dispositifs"},
		Mindate:    timestamppb.Now(),
	})

	for _, e := range eventsresp.Events {
		events = append(events, e.ToStorageType())
	}

	sort.Sort(sorting.EventsByStartdate(events))

	h.Renderer.Dashboard(w, r, accounts, count, count_members, events)

}