package proxy

import (
	"91porn-server/common/log"
	"91porn-server/web/api/tianyuctrl/http"
	"bytes"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"

	"strings"
)

const (
	apiDomain = BucketVideoAddressV2 + "/file/upload"
	imgDomain = BucketImageAddressV2 + "/file/upload"
)

var (
	header = map[string]string{"Content-Type": "application/json"}
)

const (
	Success = 200
)

func UploadImg(fileName string, data []byte, domain string) (pathStr string, err error) {
	r := objreq{
		Name: fileName,
		Data: base64.StdEncoding.EncodeToString(data),
	}
	jsonbytes, err := json.Marshal(r)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = imgDomain
	}
	url := domain
	if !strings.Contains(domain, "/file/upload") {
		url = domain + "/file/upload"
	}
	resp, err := http.Post(url, header, bytes.NewReader(jsonbytes))
	if err != nil {
		return
	}

	var or objresp
	if err = json.Unmarshal(resp.Data, &or); err != nil {
		return
	}
	if or.Code != Success {
		err = fmt.Errorf("上传失败:%s", or.Msg)
		return
	}
	pathStr = or.Object.Name
	return
}

func UploadBase64Img(fileName string, data string, domain string) (pathStr string, err error) {
	r := objreq{
		Name: fileName,
		Data: data,
	}
	jsonbytes, err := json.Marshal(r)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = apiDomain
	}
	url := domain
	if !strings.Contains(domain, "/file/upload") {
		url = domain + "/file/upload"
	}
	resp, err := http.Post(url, header, bytes.NewReader(jsonbytes))
	if err != nil {
		return
	}

	var or objresp
	if err = json.Unmarshal(resp.Data, &or); err != nil {
		return
	}
	if or.Code != Success {
		err = fmt.Errorf("上传失败:%s", or.Msg)
		return
	}
	pathStr = or.Object.Name
	return
}

func fileServer() (url string) {
	return BucketVideoAddressV2
}

func PostOk(baseInfo *ShardOk, domain string) (result *VideoOkResult, err error) {
	result = &VideoOkResult{}
	paramJson, err := json.Marshal(baseInfo)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/proxy/videoOk") {
		url = domain + "/file/web/proxy/videoOk"
	}
	fmt.Println(paramJson)
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		fmt.Println(result)
		return nil, err
	}
	fmt.Println(result)
	return
}
func PostOkV2(baseInfo *ShardOk, domain string) (result *VideoOkResult, err error) {
	result = &VideoOkResult{}
	paramJson, err := json.Marshal(baseInfo)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/proxy/videoOkv2") {
		url = domain + "/file/web/proxy/videoOkv2"
	}
	fmt.Println(paramJson)
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		fmt.Println(result)
		return nil, err
	}
	fmt.Println(result)
	return
}
func QueryMedia(baseInfo *MediaQueryeReq, domain string) (result *VideoQueryResult, err error) {
	result = &VideoQueryResult{}
	paramJson, err := json.Marshal(baseInfo)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/query") {
		url = domain + "/file/web/media/query"
	}
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		fmt.Println(err)
		return nil, err
	}
	return
}

func QueryMedias(baseInfo *MediaQueryesReq, domain string) (result *VideoQuerysResult, err error) {
	result = &VideoQuerysResult{
		Data: make([]MediaResp, 0),
	}
	paramJson, err := json.Marshal(baseInfo)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/querys") {
		url = domain + "/file/web/media/querys"
	}
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		fmt.Println(err)
		return nil, err
	}
	return
}
func SyncMedia(baseInfo *MediaSyncReq, domain string) (result *VideoSyncResult, err error) {
	result = &VideoSyncResult{}
	paramJson, err := json.Marshal(baseInfo)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/search") {
		url = domain + "/file/web/media/search"
	}
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		fmt.Println(err, string(fr.Data))
		return nil, err
	}

	return
}

func UploadVideo(domain string, body *ShardBody) (result *Result, err error) {
	if body == nil {
		return nil, errors.New("no video to upload")
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/proxy/videoBody") {
		url = domain + "/file/web/proxy/videoBody"
	}
	fmt.Println(url)

	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	resp, err := http.Post(url, header, bytes.NewBuffer(buf))
	if err != nil {
		return nil, err
	}
	fmt.Println("resp-->", string(resp.Data))
	result = new(Result)
	if err = json.Unmarshal(resp.Data, result); err != nil {
		return nil, err
	}
	return
}
func PostSearch(param *MediaSearchReq, domain string) (result *MediaSearchResult, err error) {
	result = &MediaSearchResult{}
	paramJson, err := json.Marshal(param)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/search") {
		url = domain + "/file/web/media/search"
	}
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		log.Error(fmt.Sprintf("ty media search err:%v", err))
		return
	}
	if fr.StatusCode != 200 {
		log.Error(fmt.Sprintf("ty media search fr.StatusCode:%v", fr.StatusCode))
		return
	}

	if err = json.Unmarshal(fr.Data, result); err != nil {
		log.Error(fmt.Sprintf("ty json Unmarshal search err:%v", err))
		return nil, err
	}
	log.Info("proxy:test", log.Any("url", url), log.Any("result", result))
	return
}

func PostUpdate(param *MediaUpdateReq, domain string) (result *MediaUpdateResult, err error) {
	result = &MediaUpdateResult{}
	paramJson, err := json.Marshal(param)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/update") {
		url = domain + "/file/web/media/update"
	}
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		return nil, err
	}
	return
}

func PostDelete(param *MediaDelReq, domain string) (result *MediaDelResult, err error) {
	result = &MediaDelResult{}
	paramJson, err := json.Marshal(param)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/delete") {
		url = domain + "/file/web/media/delete"
	}
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		return nil, err
	}
	return
}

func PostUpdatePreTime(param *MediaUpdatePreTime, domain string) (result *MediaDelResult, err error) {
	result = &MediaDelResult{}
	paramJson, err := json.Marshal(param)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/update/prefile") {
		url = domain + "/file/web/media/update/prefile"
	}
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		return nil, err
	}
	return
}

func UploadVideoV2(domain string, body *ShardBodyV2) (result *Result, err error) {
	if body == nil {
		return nil, errors.New("no video to upload")
	}
	if len(domain) == 0 {
		domain = fileServer()
	}
	url := domain
	if !strings.Contains(domain, "/file/web/proxy/videoBodyV2") {
		url = domain + "/file/web/proxy/videoBodyV2"
	}
	fmt.Println(url)

	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	resp, err := http.Post(url, header, bytes.NewBuffer(buf))
	if err != nil {
		return nil, err
	}
	fmt.Println("resp-->", string(resp.Data))
	result = new(Result)
	if err = json.Unmarshal(resp.Data, result); err != nil {
		return nil, err
	}

	fmt.Println("result-->", result)
	if result.Code != 200 {
		err = fmt.Errorf("result code err")
	}
	return
}