package providers

import (
	"cmdb-backend/models"
	"cmdb-backend/pkg/app/request"
	"cmdb-backend/pkg/config"
	"cmdb-backend/pkg/logging"
	"cmdb-backend/pkg/utils"
	"context"
	"fmt"
	"strconv"
	"strings"
)

type ncDomainsResp struct {
	ApiResponse apiResponse
}

type apiResponse struct {
	RequestedCommand string `json:"RequestedCommand"`
	CommandResponse  commandResponse
}

type commandResponse struct {
	DomainGetListResult     domainGetListResult
	DomainDNSGetHostsResult domainDNSGetHostsResult
}

type domainGetListResult struct {
	Domain []ncDomainInfo
}

type ncDomainInfo struct {
	Name    string `json:"-Name"`
	Id      string `json:"-ID"`
	Created string `json:"-Created"`
	Expires string `json:"-Expires"`
}

type ncRecordResp struct {
	ApiResponse api1Response
}

type api1Response struct {
	CommandResponse hostCommandResponse
}

type hostCommandResponse struct {
	DomainDNSGetHostsResult domainDNSGetHostsResult
}

type domainDNSGetHostsResult struct {
	Host []ncRecordInfo
}
type ncRecordInfo struct {
	Id     string `json:"-HostId"`
	Name   string `json:"-Name"`
	Type   string `json:"-Type"`
	Ttl    string `json:"-TTL"`
	Status string `json:"-IsActive"`
	Target string `json:"-Address"`
}

func Namecheap() {
	accessKey := config.GC.Vendor.NamecheapAk
	clientIp := config.GC.Vendor.ClientIp
	url := "https://api.namecheap.com/xml.response?"
	permit := fmt.Sprintf("ApiUser=pingcap&UserName=pingcap&ApiKey=%s&ClientIp=%s", accessKey, clientIp)
	ctx := context.Background()

	//获取 zone 列表
	resp, err := request.Get(ctx,
		fmt.Sprintf(url+permit+"&Command=namecheap.domains.getList&PageSize=50"),
	)
	if err != nil {
		logging.Error("get namecheap domain list error ", err)
		return
	}

	domainList := ncDomainsResp{}
	if err = resp.XmlToJSON(&domainList); err != nil {
		logging.Error("json namecheap zone err ", err)
	}

	zoneList := domainList.ApiResponse.CommandResponse.DomainGetListResult.Domain
	for _, domain := range zoneList {
		id, _ := strconv.Atoi(domain.Id)
		zone := models.DnsZone{
			VendorId: 10,
			ZoneId:   id,
			Status:   "ENABLE",
			Name:     domain.Name,
		}
		fmt.Println(zone)
		//写入数据库
		if err := models.CreateDnsZone(zone); err != nil {
			logging.Error("Add dns zone failed !", err)
		}

		// 获取 domain 下面的 record，然后入库
		Sld := strings.Split(domain.Name, ".")[0]
		Tld := strings.Split(domain.Name, ".")[1]
		rep, err := request.Get(ctx,
			fmt.Sprintf(url+permit+"&Command=namecheap.domains.dns.getHosts&SLD=%s&TLD=%s", Sld, Tld),
		)
		if err != nil {
			logging.Error("get namecheap dns record err ", err)
		}

		recordList := ncRecordResp{}
		err = rep.XmlToJSON(&recordList)
		if err != nil {
			logging.Error(fmt.Sprintf("json namecheap %s page record failed ! ", domain.Name), err)
		}
		recordList1 := recordList.ApiResponse.CommandResponse.DomainDNSGetHostsResult.Host

		fmt.Printf(" %s 域名记录总条数：%d \n", domain.Name, len(recordList1))

		for _, record := range recordList1 {
			zid, _ := strconv.Atoi(domain.Id)
			rid, _ := strconv.ParseInt(record.Id, 10, 64)
			ttl, _ := strconv.Atoi(record.Ttl)
			dnsRecord := models.DnsRecord{
				RecordId: rid,
				VendorId: 10,
				Line:     "默认",
				Ttl:      ttl,
				ZoneId:   zid,
				ZoneName: domain.Name,
				Name:     record.Name,
				Type:     record.Type,
				Target:   record.Target,
				Status:   record.Status,
			}
			fmt.Println(dnsRecord)
			//写入数据库
			if err = models.InitDnsRecord(dnsRecord); err != nil {
				logging.Error(fmt.Sprintf("Add namecheap %s page record failed !", domain.Name), err)
			}
		}

	}
	return
}

func NamecheapGetDomainList() {
	accessKey := config.GC.Vendor.NamecheapAk
	clientIp := config.GC.Vendor.ClientIp
	url := "https://api.namecheap.com/xml.response?"
	permit := fmt.Sprintf("ApiUser=pingcap&UserName=pingcap&ApiKey=%s&ClientIp=%s", accessKey, clientIp)
	ctx := context.Background()

	//获取 zone 列表
	resp, err := request.Get(ctx,
		fmt.Sprintf(url+permit+"&Command=namecheap.domains.getList&PageSize=50"),
	)
	if err != nil {
		logging.Error("get namecheap domain list error ", err)
	}

	domainList := ncDomainsResp{}
	if err = resp.XmlToJSON(&domainList); err != nil {
		logging.Error("json namecheap zone err ", err)
	}
	zoneList := domainList.ApiResponse.CommandResponse.DomainGetListResult.Domain
	for _, tmp := range zoneList {
		tmpCreated := strings.Split(tmp.Created, "/")
		createAt := fmt.Sprintf(tmpCreated[2] + "-" + tmpCreated[0] + "-" + tmpCreated[1] + " 00:00:00")
		tmpExpire := strings.Split(tmp.Expires, "/")
		expireAt := fmt.Sprintf(tmpExpire[2] + "-" + tmpExpire[0] + "-" + tmpExpire[1] + " 00:00:00")

		domain1 := models.Domain{
			Name:        tmp.Name,
			Status:      "SUCCEED",
			Grade:       "B",
			VendorId:    10,
			IsIcp:       2,
			IcpCode:     "",
			Owner:       "",
			Remark:      "",
			Possessor:   "PingCAP Ltd.",
			CreateTime:  utils.Str2Time(createAt),
			ExpiredTime: utils.Str2Time(expireAt),
		}
		fmt.Println(domain1)
		//写入数据库
		//if err = models.CreateDomainRecord(&domain1); err != nil {
		//	fmt.Println(err)
		//	logging.Error("Add domain failed !", err)
		//}
	}
}