package demo

import (
	portainer "github.com/portainer/portainer/api"
	"github.com/portainer/portainer/api/dataservices"

	"github.com/pkg/errors"
	"github.com/rs/zerolog/log"
)

type EnvironmentDetails struct {
	Enabled      bool                   `json:"enabled"`
	Users        []portainer.UserID     `json:"users"`
	Environments []portainer.EndpointID `json:"environments"`
}

type Service struct {
	details EnvironmentDetails
}

func NewService() *Service {
	return &Service{}
}

func (service *Service) Details() EnvironmentDetails {
	return service.details
}

func (service *Service) Init(store dataservices.DataStore, cryptoService portainer.CryptoService) error {
	log.Info().Msg("starting demo environment")

	isClean, err := isCleanStore(store)
	if err != nil {
		return errors.WithMessage(err, "failed checking if store is clean")
	}

	if !isClean {
		return errors.New(" Demo environment can only be initialized on a clean database")
	}

	id, err := initDemoUser(store, cryptoService)
	if err != nil {
		return errors.WithMessage(err, "failed creating demo user")
	}

	endpointIds, err := initDemoEndpoints(store)
	if err != nil {
		return errors.WithMessage(err, "failed creating demo endpoint")
	}

	err = initDemoSettings(store)
	if err != nil {
		return errors.WithMessage(err, "failed updating demo settings")
	}

	service.details = EnvironmentDetails{
		Enabled: true,
		Users:   []portainer.UserID{id},
		// endpoints 2,3 are created after deployment of portainer
		Environments: endpointIds,
	}

	return nil
}

func isCleanStore(store dataservices.DataStore) (bool, error) {
	endpoints, err := store.Endpoint().Endpoints()
	if err != nil {
		return false, err
	}

	if len(endpoints) > 0 {
		return false, nil
	}

	users, err := store.User().ReadAll()
	if err != nil {
		return false, err
	}

	if len(users) > 0 {
		return false, nil
	}

	return true, nil
}

func (service *Service) IsDemo() bool {
	return service.details.Enabled
}

func (service *Service) IsDemoEnvironment(environmentID portainer.EndpointID) bool {
	if !service.IsDemo() {
		return false
	}

	for _, demoEndpointID := range service.details.Environments {
		if environmentID == demoEndpointID {
			return true
		}
	}

	return false
}

func (service *Service) IsDemoUser(userID portainer.UserID) bool {
	if !service.IsDemo() {
		return false
	}

	for _, demoUserID := range service.details.Users {
		if userID == demoUserID {
			return true
		}
	}

	return false
}