package main

import (
	"context"
	"log"
	"net/http"

	"git.itzana.me/strafesnet/maps-service/api"
	"git.itzana.me/strafesnet/maps-service/internal/controller/submissions"
	"git.itzana.me/strafesnet/maps-service/internal/controller/users"
)

type apiServer struct {
	submissions *submissions.Submissions
	users *users.Users
}

// GetUserRank implements api.Handler.
func (m *apiServer) GetSubmission(ctx context.Context, params api.GetSubmissionParams) (*api.Submission, error) {
	return m.submissions.Get(ctx,params)
}

// NewError implements api.Handler.
func (m *apiServer) NewError(ctx context.Context, err error) *api.ErrorStatusCode {
	return &api.ErrorStatusCode{
		StatusCode: 500,
		Response:   api.Error{Message: err.Error()},
	}
}

func main() {
	// new grpc client
	conn, err := grpc.Dial("localhost:9000", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatal(err)
	}

	svc := &apiServer{
		client: conn,
	}

	srv, err := api.NewServer(
		svc,
		api.WithPathPrefix("/v2"),
	)
	if err != nil {
		log.Fatal(err)
	}

	if err := http.ListenAndServe(":8080", srv); err != nil {
		log.Fatal(err)
	}
}

func convertTime(t *times.TimeResponse) api.Time {
	return api.Time{
		ID:   api.NewOptInt64(t.ID),
		Time: api.NewOptInt64(t.Time),
		User: api.NewOptUser(api.User{
			ID:       api.NewOptInt64(t.User.ID),
			Username: api.NewOptString(t.User.Username),
			StateID:  api.NewOptInt32(t.User.StateID),
		}),
		Map: api.NewOptMap(api.Map{
			ID:          api.NewOptInt64(t.Map.ID),
			DisplayName: api.NewOptString(t.Map.DisplayName),
			Creator:     api.NewOptString(t.Map.Creator),
			Date:        api.NewOptInt64(t.Map.Date),
		}),
		Date:    api.NewOptInt64(t.Date),
		StyleID: api.NewOptInt32(t.StyleID),
		ModeID:  api.NewOptInt32(t.ModeID),
		GameID:  api.NewOptInt32(t.GameID),
	}
}

func convertTimes(timeList []*times.TimeResponse) []api.Time {
	times := make([]api.Time, len(timeList))
	for i, t := range timeList {
		times[i] = convertTime(t)
	}
	return times
}