package httpdns

import (
	"context"
	"errors"
	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
	"github.com/TeaOSLab/EdgeAPI/internal/rpc/services"
	"github.com/TeaOSLab/EdgeCommon/pkg/rpc/pb"
	"github.com/iwind/TeaGo/dbs"
)

// HTTPDNSClusterService HTTPDNS集群服务
type HTTPDNSClusterService struct {
	services.BaseService
	pb.UnimplementedHTTPDNSClusterServiceServer
}

func (this *HTTPDNSClusterService) CreateHTTPDNSCluster(ctx context.Context, req *pb.CreateHTTPDNSClusterRequest) (*pb.CreateHTTPDNSClusterResponse, error) {
	_, err := this.ValidateAdmin(ctx)
	if err != nil {
		return nil, err
	}
	if len(req.Name) == 0 {
		return nil, errors.New("required 'name'")
	}
	var clusterId int64
	err = this.RunTx(func(tx *dbs.Tx) error {
		clusterId, err = models.SharedHTTPDNSClusterDAO.CreateCluster(tx, req.Name, req.ServiceDomain, req.DefaultTTL, req.FallbackTimeoutMs, req.InstallDir, req.TlsPolicyJSON, req.IsOn, req.IsDefault)
		if err != nil {
			return err
		}
		return notifyHTTPDNSClusterTask(tx, clusterId, models.HTTPDNSNodeTaskTypeConfigChanged)
	})
	if err != nil {
		return nil, err
	}
	return &pb.CreateHTTPDNSClusterResponse{ClusterId: clusterId}, nil
}

func (this *HTTPDNSClusterService) UpdateHTTPDNSCluster(ctx context.Context, req *pb.UpdateHTTPDNSClusterRequest) (*pb.RPCSuccess, error) {
	_, err := this.ValidateAdmin(ctx)
	if err != nil {
		return nil, err
	}
	err = this.RunTx(func(tx *dbs.Tx) error {
		err = models.SharedHTTPDNSClusterDAO.UpdateCluster(tx, req.ClusterId, req.Name, req.ServiceDomain, req.DefaultTTL, req.FallbackTimeoutMs, req.InstallDir, req.TlsPolicyJSON, req.IsOn, req.IsDefault)
		if err != nil {
			return err
		}
		taskType := models.HTTPDNSNodeTaskTypeConfigChanged
		if len(req.TlsPolicyJSON) > 0 {
			taskType = models.HTTPDNSNodeTaskTypeTLSChanged
		}
		return notifyHTTPDNSClusterTask(tx, req.ClusterId, taskType)
	})
	if err != nil {
		return nil, err
	}
	return this.Success()
}

func (this *HTTPDNSClusterService) DeleteHTTPDNSCluster(ctx context.Context, req *pb.DeleteHTTPDNSClusterRequest) (*pb.RPCSuccess, error) {
	_, err := this.ValidateAdmin(ctx)
	if err != nil {
		return nil, err
	}
	err = this.RunTx(func(tx *dbs.Tx) error {
		err = models.SharedHTTPDNSClusterDAO.DisableCluster(tx, req.ClusterId)
		if err != nil {
			return err
		}
		return notifyHTTPDNSClusterTask(tx, req.ClusterId, models.HTTPDNSNodeTaskTypeConfigChanged)
	})
	if err != nil {
		return nil, err
	}
	return this.Success()
}

func (this *HTTPDNSClusterService) FindHTTPDNSCluster(ctx context.Context, req *pb.FindHTTPDNSClusterRequest) (*pb.FindHTTPDNSClusterResponse, error) {
	_, err := this.ValidateAdmin(ctx)
	if err != nil {
		return nil, err
	}
	cluster, err := models.SharedHTTPDNSClusterDAO.FindEnabledCluster(this.NullTx(), req.ClusterId)
	if err != nil {
		return nil, err
	}
	return &pb.FindHTTPDNSClusterResponse{Cluster: toPBCluster(cluster)}, nil
}

func (this *HTTPDNSClusterService) ListHTTPDNSClusters(ctx context.Context, req *pb.ListHTTPDNSClustersRequest) (*pb.ListHTTPDNSClustersResponse, error) {
	_, err := this.ValidateAdmin(ctx)
	if err != nil {
		return nil, err
	}
	clusters, err := models.SharedHTTPDNSClusterDAO.ListEnabledClusters(this.NullTx(), req.Offset, req.Size, req.Keyword)
	if err != nil {
		return nil, err
	}
	var pbClusters []*pb.HTTPDNSCluster
	for _, cluster := range clusters {
		pbClusters = append(pbClusters, toPBCluster(cluster))
	}
	return &pb.ListHTTPDNSClustersResponse{Clusters: pbClusters}, nil
}

func (this *HTTPDNSClusterService) FindAllHTTPDNSClusters(ctx context.Context, req *pb.FindAllHTTPDNSClustersRequest) (*pb.FindAllHTTPDNSClustersResponse, error) {
	_, _, validateErr := this.ValidateAdminAndUser(ctx, true)
	if validateErr != nil {
		if _, nodeErr := this.ValidateHTTPDNSNode(ctx); nodeErr != nil {
			return nil, validateErr
		}
	}
	clusters, err := models.SharedHTTPDNSClusterDAO.FindAllEnabledClusters(this.NullTx())
	if err != nil {
		return nil, err
	}
	var pbClusters []*pb.HTTPDNSCluster
	for _, cluster := range clusters {
		pbClusters = append(pbClusters, toPBCluster(cluster))
	}
	return &pb.FindAllHTTPDNSClustersResponse{Clusters: pbClusters}, nil
}

func (this *HTTPDNSClusterService) UpdateHTTPDNSClusterDefault(ctx context.Context, req *pb.UpdateHTTPDNSClusterDefaultRequest) (*pb.RPCSuccess, error) {
	_, err := this.ValidateAdmin(ctx)
	if err != nil {
		return nil, err
	}
	err = this.RunTx(func(tx *dbs.Tx) error {
		err = models.SharedHTTPDNSClusterDAO.UpdateDefaultCluster(tx, req.ClusterId)
		if err != nil {
			return err
		}

		clusters, err := models.SharedHTTPDNSClusterDAO.FindAllEnabledClusters(tx)
		if err != nil {
			return err
		}

		for _, cluster := range clusters {
			err = notifyHTTPDNSClusterTask(tx, int64(cluster.Id), models.HTTPDNSNodeTaskTypeConfigChanged)
			if err != nil {
				return err
			}
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return this.Success()
}

func (this *HTTPDNSClusterService) ListHTTPDNSNodesWithClusterId(ctx context.Context, req *pb.ListHTTPDNSNodesWithClusterIdRequest) (*pb.ListHTTPDNSNodesWithClusterIdResponse, error) {
	_, _, err := this.ValidateAdminAndUser(ctx, true)
	if err != nil {
		return nil, err
	}
	nodes, err := models.SharedHTTPDNSNodeDAO.ListEnabledNodes(this.NullTx(), req.ClusterId)
	if err != nil {
		return nil, err
	}
	var pbNodes []*pb.HTTPDNSNode
	for _, node := range nodes {
		pbNodes = append(pbNodes, toPBNode(node))
	}
	return &pb.ListHTTPDNSNodesWithClusterIdResponse{Nodes: pbNodes}, nil
}