package proxy

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"strings"
	"videoweb/pub/common/http"
	"videoweb/pub/common/log"
)

const (
	apiDomain = "http://resourcets.bbaazz.me/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
	}
	url := ImageUploadAddressRepair(domain, BucketImageAddressV2)

	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
	if strings.Contains(domain, "resourceimg.bbaazz.me") &&
		!strings.HasPrefix(pathStr, "v2/") {
		pathStr = "v2/" + pathStr
	}
	return
}

func fileServer() (url string) {
	return "http://resourcets.bbaazz.me"
}

func PostOk(baseInfo *ShardOk, domain string) (result *VideoOkResult, err error) {
	result = &VideoOkResult{}
	paramJson, err := json.Marshal(baseInfo)
	if err != nil {
		return
	}
	url := VideoOkAddressRepair(domain, BucketVideoAddressV2)
	fmt.Println(baseInfo)
	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	fmt.Println(string(fr.Data))
	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
	}
	url := VideoOkAddressRepair(domain, BucketVideoAddressV2)
	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 = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	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 = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	url := domain
	if !strings.Contains(domain, "/media/web/task/querys") {
		url = domain + "/media/web/task/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 UploadVideo(domain string, body *ShardBody) (result *Result, err error) {
	if body == nil {
		return nil, errors.New("no video to upload")
	}
	url := VideoBodyAddressRepair(domain, BucketVideoAddressV2)
	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 UploadVideoV2(domain string, body *ShardBodyV2) (result *Result, err error) {
	if body == nil {
		return nil, errors.New("no video to upload")
	}
	url := VideoBodyAddressRepair(domain, BucketVideoAddressV2)
	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 = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	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 {
		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 = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	url := domain
	if !strings.Contains(domain, "/file/web/media/update") {
		url = domain + "/file/web/media/update"
	}
	fr, perr := http.Post(url, header, bytes.NewReader(paramJson))
	if perr != nil {
		log.Error("PostUpdate Unmarshal", log.E(perr))
		err = perr
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		log.Error("PostUpdate Unmarshal", log.E(err), log.Any("data", string(fr.Data)))
		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 = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	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 = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	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 UploadVideoV2New(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
	}
	// if strings.Contains(domain, "resourcets.bbaazz.me") && !strings.HasPrefix(result.Data.VideoUri, "v2/") {
	// 	result.Data.VideoUri = "v2/" + result.Data.VideoUri
	// }
	fmt.Println("result-->", result)
	if result.Code != 200 {
		err = fmt.Errorf("result code err")
	}
	return
}
func SyncMedia(baseInfo *MediaTaskSyncReq, domain string) (result *VideoQuerysResult, err error) {
	result = &VideoQuerysResult{}
	paramJson, err := json.Marshal(baseInfo)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	url := domain
	if !strings.Contains(domain, "/media/web/task/sync") {
		url = domain + "/media/web/task/sync"
	}
	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
}

// SyncMediaFile 将相对路径 m3u8 登记到 media 切片服（status=MediaFileSyncing）
func SyncMediaFile(req *MediaFileSyncReq, domain string) (result *MediaAPIResult, err error) {
	result = &MediaAPIResult{}
	paramJson, err := json.Marshal(req)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	url := domain
	if !strings.Contains(domain, "/media/web/mediafile/sync") {
		url = domain + "/media/web/mediafile/sync"
	}
	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
}

// AddMediaTask 提交 media 加水印切片任务
func AddMediaTask(req *MediaTaskAddReq, domain string) (result *MediaAPIResult, err error) {
	result = &MediaAPIResult{}
	paramJson, err := json.Marshal(req)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	url := domain
	if !strings.Contains(domain, "/media/web/task/add") {
		url = domain + "/media/web/task/add"
	}
	reqHeader := map[string]string{
		"Content-Type": "application/json",
		"acc-id":       "1",
		"acc-name":     "playlet-watermark",
		"app-id":       fmt.Sprintf("%d", req.AppId),
	}
	fr, err := http.Post(url, reqHeader, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		return nil, err
	}
	return
}

// UpdateMediaWatermark 按已有 media 任务重新加水印切片
func UpdateMediaWatermark(req *MediaTaskUpdateWatermarkReq, domain string) (result *MediaAPIResult, err error) {
	result = &MediaAPIResult{}
	paramJson, err := json.Marshal(req)
	if err != nil {
		return
	}
	if len(domain) == 0 {
		domain = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	url := domain
	if !strings.Contains(domain, "/media/web/task/update/watermark") {
		url = domain + "/media/web/task/update/watermark"
	}
	reqHeader := map[string]string{
		"Content-Type": "application/json",
		"acc-id":       "1",
		"acc-name":     "playlet-watermark",
		"app-id":       fmt.Sprintf("%d", req.AppId),
	}
	fr, err := http.Post(url, reqHeader, bytes.NewReader(paramJson))
	if err != nil {
		return
	}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		return nil, err
	}
	return
}

// QueryMediaSource 按原片 ID 查询 media source 状态
func QueryMediaSource(sourceID string, appId int64, domain string) (*MediaSourceListItem, error) {
	req := MediaSourceListReq{
		Id:       sourceID,
		AppId:    appId,
		WebAppId: appId,
		PageNum:  1,
		PageSize: 1,
	}
	paramJSON, err := json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if len(domain) == 0 {
		domain = DomainAddressRepair(domain, BucketVideoAddressV2)
	}
	url := domain
	if !strings.Contains(domain, "/media/web/source/list") {
		url = domain + "/media/web/source/list"
	}
	reqHeader := map[string]string{
		"Content-Type": "application/json",
		"acc-id":       "1",
		"acc-name":     "playlet-watermark",
		"app-id":       fmt.Sprintf("%d", appId),
	}
	fr, err := http.Post(url, reqHeader, bytes.NewReader(paramJSON))
	if err != nil {
		return nil, err
	}
	result := &MediaSourceListResult{}
	if err = json.Unmarshal(fr.Data, result); err != nil {
		return nil, err
	}
	if result.Code != Success || len(result.Data.List) == 0 {
		return nil, nil
	}
	return &result.Data.List[0], nil
}