package registration

import (
	"fmt"

	"edge-infra.dev/pkg/edge/constants/api/cluster"
)

const DefaultLumperImage = "us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/lumperctl:latest"

type Builder struct {
	reg Registration
}

func NewBuilder() *Builder {
	return &Builder{}
}

// Build returns a valid Registration object
func (b *Builder) Build() (*Registration, error) {
	if err := b.reg.Bff.Valid(); err != nil {
		return nil, err
	}
	if err := b.reg.Cluster.Valid(); err != nil {
		return nil, err
	}
	return &b.reg, nil
}

// BootstrapBuild returns a valid Registration object for bootstrapping
func (b *Builder) BootstrapBuild() (*Registration, error) {
	if err := b.reg.Bff.Valid(); err != nil {
		return nil, err
	}
	if err := b.reg.Cluster.ValidForBootstrapping(); err != nil {
		return nil, err
	}
	return &b.reg, nil
}

// BFF fields

func (b *Builder) APIEndpoint(endpoint string) *Builder {
	b.reg.Bff.APIEndpoint = endpoint
	return b
}

func (b *Builder) BearerToken(bearerToken string) *Builder {
	b.reg.Bff.BearerToken = bearerToken
	return b
}

func (b *Builder) BSLUserPassword(user, pwd string) *Builder {
	b.reg.Bff.BSLUser = user
	b.reg.Bff.BSLPassword = pwd
	return b
}

func (b *Builder) TotpToken(token string) *Builder {
	b.reg.Bff.TotpToken = token
	return b
}

func (b *Builder) BSLOrganization(org string) *Builder {
	b.reg.Bff.BSLOrganization = org
	return b
}

// Cluster Info
func (b *Builder) Banner(banner string) *Builder {
	b.reg.Cluster.Banner = banner
	return b
}

func (b *Builder) BannerEdgeID(bannerEdgeID string) *Builder {
	b.reg.Cluster.BannerEdgeID = bannerEdgeID
	return b
}

func (b *Builder) Store(store string) *Builder {
	b.reg.Cluster.Store = store
	return b
}

func (b *Builder) ClusterType(clusterType string) *Builder {
	b.reg.Cluster.ClusterType = clusterType
	return b
}

func (b *Builder) ClusterEdgeID(clusterEdgeID string) *Builder {
	b.reg.Cluster.ClusterEdgeID = clusterEdgeID
	return b
}

func (b *Builder) ClusterCaHash(clusterCaHash string) *Builder {
	b.reg.Cluster.ClusterCaHash = clusterCaHash
	return b
}

func (b *Builder) ForceBootstrap(force bool) *Builder {
	b.reg.Cluster.ForceBootstrap = force
	return b
}

// BFF Info

func (b *Builder) CreateBSLSite(createBSLSite bool) *Builder {
	b.reg.Bff.CreateBSLSite = createBSLSite
	return b
}

func (b *Builder) BSLSiteEuid(id string) *Builder {
	b.reg.Bff.BSLSiteEuid = id
	return b
}

func (b *Builder) BSLSiteLatitude(latitude float64) *Builder {
	b.reg.Bff.BSLSiteLatitude = latitude
	return b
}

func (b *Builder) BSLSiteLongitude(longitude float64) *Builder {
	b.reg.Bff.BSLSiteLongitude = longitude
	return b
}

func (b *Builder) BSLSiteReferenceID(referenceID string) *Builder {
	b.reg.Bff.BSLSiteReferenceID = referenceID
	return b
}

func (b *Builder) Fleet(fleet string) *Builder {
	b.reg.Cluster.Fleet = fleet
	return b
}

func (b *Builder) FleetVersion(fleetVersion string) *Builder {
	b.reg.Cluster.FleetVersion = fleetVersion
	return b
}

// CLI Version
func (b *Builder) EdgeVersion(version string) *Builder {
	b.reg.Bff.EdgeVersion = version
	return b
}

func (b *Builder) MachineType(machineType string) *Builder {
	b.reg.Cluster.MachineType = machineType
	return b
}

func (b *Builder) Autoscale(autoscale bool) *Builder {
	b.reg.Cluster.Autoscale = autoscale
	return b
}

func (b *Builder) Location(location string) *Builder {
	b.reg.Cluster.Location = location
	return b
}

func (b *Builder) MinNodes(minNodes int) *Builder {
	b.reg.Cluster.MinNodes = minNodes
	return b
}

func (b *Builder) MaxNodes(maxNodes int) *Builder {
	b.reg.Cluster.MaxNodes = maxNodes
	return b
}

// Fields validation

func (b BffConfig) Valid() error {
	if b.APIEndpoint == "" {
		return fmt.Errorf("backend api endpoint is not provided")
	}
	userPasswordProvided := b.BSLUser != "" && b.BSLPassword != ""
	totpTokenProvided := b.TotpToken != ""
	bearerTokenProvided := b.BearerToken != ""
	if !userPasswordProvided && !totpTokenProvided && !bearerTokenProvided {
		return fmt.Errorf("bsl user/password, bearer or totp token credentials not provided")
	}
	if userPasswordProvided && b.BSLOrganization == "" {
		return fmt.Errorf("bsl organization is not provided")
	}
	if b.CreateBSLSite && b.BSLSiteEuid == "" {
		if b.BSLSiteLatitude < -90 || b.BSLSiteLatitude > 90 {
			return fmt.Errorf("provided bsl latitide is not within the range of -90.0 and 90.0")
		}
		if b.BSLSiteLongitude < -180 || b.BSLSiteLongitude > 180 {
			return fmt.Errorf("provided bsl longitude is not within the range of -180.0 and 180.0")
		}
	}
	if b.BSLOrganization == "" && !bearerTokenProvided {
		return fmt.Errorf("BSL Banner not provided")
	}
	return nil
}

func (r ClusterInfo) Valid() error {
	if r.Banner == "" {
		return fmt.Errorf("banner is not provided")
	}
	if r.Store == "" {
		return fmt.Errorf("store is not provided")
	}
	if r.ClusterType == "" {
		return fmt.Errorf("cluster type is not provided")
	}
	if r.Fleet == "" {
		return fmt.Errorf("fleetType type is not provided")
	}
	return nil
}

func (r ClusterInfo) ValidForBootstrapping() error {
	if r.ClusterEdgeID == "" {
		return fmt.Errorf("cluster edge id is not provided")
	}
	return nil
}

func (r ClusterInfo) IsGKE() bool {
	return r.ClusterType == cluster.GKE
}