package plug

import (
	"context"
	"fmt"
	"log"
	"net"

	"git.anthrove.art/Anthrove/otter-space-sdk/v3/pkg/database"
	otterError "git.anthrove.art/Anthrove/otter-space-sdk/v3/pkg/error"
	"git.anthrove.art/Anthrove/otter-space-sdk/v3/pkg/models"

	"github.com/golang/protobuf/ptypes/timestamp"

	pb "git.anthrove.art/Anthrove/plug-sdk/v3/pkg/grpc"
	"google.golang.org/grpc"
)

type Message struct {
	Title     string
	Body      string
	CreatedAt *timestamp.Timestamp
}

type TaskExecution func(ctx context.Context, userSourceUsername string, anthroveUser models.User, deepScrape bool, apiKey string, cancelFunction func()) error
type SendMessageExecution func(ctx context.Context, userSourceID string, userSourceUsername string, message string) error
type GetMessageExecution func(ctx context.Context, userSourceID string, userSourceUsername string) ([]Message, error)

type Plug struct {
	address               string
	port                  string
	ctx                   context.Context
	taskExecutionFunction TaskExecution
	sendMessageExecution  SendMessageExecution
	getMessageExecution   GetMessageExecution
	source                models.Source
}

func NewPlug(ctx context.Context, address string, port string, source models.Source) Plug {
	return Plug{
		ctx:     ctx,
		address: address,
		port:    port,
		source:  source,
	}
}

func (p *Plug) Listen() error {
	var err error

	log.Print("Check if source exists")
	_, err = database.GetSourceByDomain(p.ctx, p.source.Domain)
	if err != nil {
		if err.Error() == otterError.NoDataFound {
			log.Printf("iIitializing source!")
			if _, err = database.CreateSource(p.ctx, p.source); err != nil {
				panic(err)
			}
		} else {
			panic(err)
		}
	}

	log.Print("Source exists")

	lis, err := net.Listen("tcp", fmt.Sprintf("%s:%s", p.address, p.port))
	if err != nil {
		return err
	}

	grpcServer := grpc.NewServer()

	pb.RegisterPlugConnectorServer(grpcServer, NewGrpcServer(p.taskExecutionFunction, p.sendMessageExecution, p.getMessageExecution))

	err = grpcServer.Serve(lis)
	if err != nil {
		return err
	}

	return nil
}

func (p *Plug) TaskExecutionFunction(function TaskExecution) {
	p.taskExecutionFunction = function
}

func (p *Plug) SendMessageExecution(function SendMessageExecution) {
	p.sendMessageExecution = function
}

func (p *Plug) GetMessageExecution(function GetMessageExecution) {
	p.getMessageExecution = function
}