package httpdns

import (
	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
	"github.com/TeaOSLab/EdgeCommon/pkg/rpc/pb"
)

func toPBCluster(cluster *models.HTTPDNSCluster) *pb.HTTPDNSCluster {
	if cluster == nil {
		return nil
	}
	return &pb.HTTPDNSCluster{
		Id:                int64(cluster.Id),
		IsOn:              cluster.IsOn,
		IsDefault:         cluster.IsDefault,
		Name:              cluster.Name,
		ServiceDomain:     cluster.ServiceDomain,
		DefaultTTL:        cluster.DefaultTTL,
		FallbackTimeoutMs: cluster.FallbackTimeoutMs,
		InstallDir:        cluster.InstallDir,
		TlsPolicyJSON:     cluster.TLSPolicy,
		CreatedAt:         int64(cluster.CreatedAt),
		UpdatedAt:         int64(cluster.UpdatedAt),
	}
}

func toPBNode(node *models.HTTPDNSNode) *pb.HTTPDNSNode {
	if node == nil {
		return nil
	}
	return &pb.HTTPDNSNode{
		Id:                int64(node.Id),
		ClusterId:         int64(node.ClusterId),
		Name:              node.Name,
		IsOn:              node.IsOn,
		IsUp:              node.IsUp,
		IsInstalled:       node.IsInstalled,
		IsActive:          node.IsActive,
		UniqueId:          node.UniqueId,
		Secret:            node.Secret,
		InstallDir:        node.InstallDir,
		StatusJSON:        node.Status,
		InstallStatusJSON: node.InstallStatus,
		CreatedAt:         int64(node.CreatedAt),
		UpdatedAt:         int64(node.UpdatedAt),
	}
}

func toPBApp(app *models.HTTPDNSApp, secret *models.HTTPDNSAppSecret) *pb.HTTPDNSApp {
	if app == nil {
		return nil
	}
	var signEnabled bool
	var signSecret string
	var signUpdatedAt int64
	if secret != nil {
		signEnabled = secret.SignEnabled
		signSecret = secret.SignSecret
		signUpdatedAt = int64(secret.SignUpdatedAt)
	}
	return &pb.HTTPDNSApp{
		Id:               int64(app.Id),
		Name:             app.Name,
		AppId:            app.AppId,
		IsOn:             app.IsOn,
		PrimaryClusterId: int64(app.PrimaryClusterId),
		BackupClusterId:  int64(app.BackupClusterId),
		SniMode:          app.SNIMode,
		SignEnabled:      signEnabled,
		SignSecret:       signSecret,
		SignUpdatedAt:    signUpdatedAt,
		CreatedAt:        int64(app.CreatedAt),
		UpdatedAt:        int64(app.UpdatedAt),
		UserId:           int64(app.UserId),
	}
}

func toPBDomain(domain *models.HTTPDNSDomain, ruleCount int64) *pb.HTTPDNSDomain {
	if domain == nil {
		return nil
	}
	return &pb.HTTPDNSDomain{
		Id:        int64(domain.Id),
		AppId:     int64(domain.AppId),
		Domain:    domain.Domain,
		IsOn:      domain.IsOn,
		CreatedAt: int64(domain.CreatedAt),
		UpdatedAt: int64(domain.UpdatedAt),
		RuleCount: ruleCount,
	}
}

func toPBRule(rule *models.HTTPDNSCustomRule, records []*models.HTTPDNSCustomRuleRecord) *pb.HTTPDNSCustomRule {
	if rule == nil {
		return nil
	}
	var pbRecords []*pb.HTTPDNSRuleRecord
	for _, record := range records {
		pbRecords = append(pbRecords, &pb.HTTPDNSRuleRecord{
			Id:          int64(record.Id),
			RuleId:      int64(record.RuleId),
			RecordType:  record.RecordType,
			RecordValue: record.RecordValue,
			Weight:      record.Weight,
			Sort:        record.Sort,
		})
	}
	return &pb.HTTPDNSCustomRule{
		Id:            int64(rule.Id),
		AppId:         int64(rule.AppId),
		DomainId:      int64(rule.DomainId),
		RuleName:      rule.RuleName,
		LineScope:     rule.LineScope,
		LineCarrier:   rule.LineCarrier,
		LineRegion:    rule.LineRegion,
		LineProvince:  rule.LineProvince,
		LineContinent: rule.LineContinent,
		LineCountry:   rule.LineCountry,
		Ttl:           rule.TTL,
		IsOn:          rule.IsOn,
		Priority:      rule.Priority,
		UpdatedAt:     int64(rule.UpdatedAt),
		Records:       pbRecords,
	}
}