package v1

import (
	"context"
	"log"

	"cloud.google.com/go/firestore"
	firebase "firebase.google.com/go"
	v1 "github.com/ElonSalfati/events-manager/pkg/api/v1"

	"google.golang.org/api/iterator"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"github.com/mitchellh/mapstructure"
)

// The accepted version of the API
const apiVersion = "v1"
const eventsCollectionPath = "events"

// eventsServiceServer is implementation of
// v1.EventsManagerServiceServer proto intrface
type eventsServiceServer struct {
	client *firestore.Client
	app    *firebase.App
}

// NewEventsServiceServer connection to firestore app
func NewEventsServiceServer(app *firebase.App, client *firestore.Client) v1.EventsManagerServiceServer {
	return &eventsServiceServer{
		app:    app,
		client: client,
	}
}

// ----------------- //
// Implement methods //
// ----------------- //

// checkAPI verifies the API version
func (s *eventsServiceServer) checkAPI(api string) error {
	// If API version is an empty string force current version
	if len(api) > 0 {
		if apiVersion != api {
			return status.Errorf(codes.Unimplemented,
				"Unsupported API version: service implements API version '%s', but asked for '%s'", apiVersion, api)
		}
	}

	// given version is fine
	return nil
}

// CreateEvent adds a new event to firestore
func (s *eventsServiceServer) CreateEvent(ctx context.Context, req *v1.CreateEventRequest) (*v1.CreateEventResponse, error) {
	// Check if the API version requested by the client is supported by the server
	if err := s.checkAPI(req.Api); err != nil {
		return nil, err
	}

	doc, _, err := s.client.Collection(eventsCollectionPath).Add(ctx, req.Event)
	if err != nil {
		log.Printf("Faild to add event: %v", err)
		return nil, err
	}

	return &v1.CreateEventResponse{
		Api: apiVersion,
		Id:  doc.ID,
	}, nil
}

// ReadEvent pulls an event or set of events from firestore
func (s *eventsServiceServer) ReadEvent(ctx context.Context, req *v1.ReadEventRequest) (*v1.ReadEventResponse, error) {
	// Check if the API version requested by the client is supported by the server
	if err := s.checkAPI(req.Api); err != nil {
		return nil, err
	}

	events := []*v1.Event{}
	if req.Id == "all" {
		iter := s.client.Collection(eventsCollectionPath).Documents(ctx)
		for {
			doc, err := iter.Next()
			if err == iterator.Done {
				break
			}
			if err != nil {
				log.Printf("Failed to iterate over documents: %v", err)
				return nil, err
			}

			var event v1.Event
			mapstructure.Decode(doc.Data(), &event)
			events = append(events, &event)
		}
	} else {
		docRef := s.client.Collection(eventsCollectionPath).Doc(req.Id)
		doc, err := docRef.Get(ctx)
		if err != nil {
			return nil, err
		}

		var event v1.Event
		mapstructure.Decode(doc.Data(), &event)
		events = append(events, &event)
	}

	return &v1.ReadEventResponse{
		Api:    apiVersion,
		Events: events,
	}, nil
}

// UpdateEvent upadtes a single event
func (s *eventsServiceServer) UpdateEvent(ctx context.Context, req *v1.UpdateEventRequest) (*v1.UpdateEventResponse, error) {
	// Check if the API version requested by the client is supported by the server
	if err := s.checkAPI(req.Api); err != nil {
		return nil, err
	}

	_, err := s.client.Collection(eventsCollectionPath).Doc(req.Event.Id).Set(ctx, req.Event, firestore.MergeAll)
	if err != nil {
		log.Printf("An error has occurred: %v", err)
		return nil, err
	}

	return &v1.UpdateEventResponse{
		Api:     apiVersion,
		Updated: true,
	}, nil
}

// DeleteEvent removes a single event
func (s *eventsServiceServer) DeleteEvent(ctx context.Context, req *v1.DeleteEventRequest) (*v1.DeleteEventResponse, error) {
	// Check if the API version requested by the client is supported by the server
	if err := s.checkAPI(req.Api); err != nil {
		return nil, err
	}

	_, err := s.client.Collection(eventsCollectionPath).Doc(req.Id).Delete(ctx)
	if err != nil {
		log.Printf("An error has occurred: %v", err)
		return nil, err
	}

	return &v1.DeleteEventResponse{
		Api:     apiVersion,
		Deleted: true,
	}, nil
}