package storage

import (
	"dashoo.cn/opms_libary/myerrors"
	"dashoo.cn/opms_libary/plugin/dingtalk/base"
	"dashoo.cn/opms_libary/plugin/dingtalk/context"
	"dashoo.cn/opms_libary/utils"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"path/filepath"
)

const (
	AddPermissionUrl         = "/v1.0/storage/spaces/%s/dentries/0/permissions"          //添加权限
	QueryFileUploadInfoUrl   = "/v1.0/storage/spaces/%s/files/uploadInfos/query"         //获取文件上传信息
	QueryFileDownloadInfoUrl = "/v1.0/storage/spaces/%s/dentries/%s/downloadInfos/query" //获取文件下载信息
	CommitFileUploadInfoUrl  = "/v1.0/storage/spaces/%s/files/commit"                    //提交文件
)

// Storage OA审批
type Storage struct {
	base.Base
}

// NewStorage init
func NewStorage(context *context.Context) *Storage {
	material := new(Storage)
	material.Context = context
	return material
}

// CreateSpaces 创建空间
func (w *Storage) CreateSpaces(spaceId, unionId string) (response QueryFileUploadInfoResponse, err error) {
	optionCapabilities := &AddSpaceRequestOptionCapabilities{
		CanSearch:           utils.Bool(true),
		CanRename:           utils.Bool(true),
		CanRecordRecentFile: utils.Bool(true),
	}
	option := &AddSpaceRequestOption{
		Name:         utils.String("OMS合同"),
		Capabilities: optionCapabilities,
		OwnerType:    utils.String("APP"),
	}
	request := &AddSpaceRequest{
		UnionId: utils.String("8xljy04PZiS9iPxp5PhDnUzQiEiE"),
		Option:  option,
	}

	resp, _ := w.HTTPPostJSONWithAccessToken("/v1.0/storage/spaces", request)
	fmt.Println(resp)
	return response, err
}

// AddPermission 添加权限
func (w *Storage) AddPermission(corpId, spaceId, unionId, roleId, memType string) (response AddPermissionResponse, err error) {
	option := &AddPermissionRequestOption{
		Duration: utils.Int64(3600),
	}
	members := &AddPermissionRequestMembers{
		Type:   utils.String(memType),
		Id:     utils.String(unionId),
		CorpId: utils.String(corpId),
	}
	request := &AddPermissionRequest{
		UnionId: utils.String(unionId),
		RoleId:  utils.String(roleId),
		Members: []*AddPermissionRequestMembers{members},
		Option:  option,
	}
	resp, err := w.HTTPPostJSONWithAccessToken(fmt.Sprintf(AddPermissionUrl, spaceId), request)
	err = json.Unmarshal(resp, &response)
	return response, err
}

// QueryFileUploadInfo 获取文件上传信息
func (w *Storage) QueryFileUploadInfo(spaceId, unionId string) (response QueryFileUploadInfoResponse, err error) {
	option := &GetFileUploadInfoRequestOption{
		StorageDriver:  utils.String("DINGTALK"),
		PreferRegion:   utils.String("SHANGHAI"),
		PreferIntranet: utils.Bool(true),
	}
	request := &GetFileUploadInfoRequest{
		UnionId:   utils.String(unionId),
		Protocol:  utils.String("HEADER_SIGNATURE"),
		Multipart: utils.Bool(false),
		Option:    option,
	}
	resp, err := w.HTTPPostJSONWithAccessToken(fmt.Sprintf(QueryFileUploadInfoUrl, spaceId), request)
	err = json.Unmarshal(resp, &response)
	return response, err
}

func (w *Storage) QueryFileDownloadInfo(spaceId, fileId, unionId string) (response QueryFileDownloadInfoResponse, err error) {
	resp, err := w.HTTPPostJSONWithAccessToken(fmt.Sprintf(QueryFileDownloadInfoUrl, spaceId, fileId)+"?unionId="+unionId, map[string]interface{}{})
	err = json.Unmarshal(resp, &response)
	return response, err

}

// UploadFile 使用OSS的header加签方式上传文件息
func (w *Storage) uploadFile(url string, headers map[string]string, filePath string) (code int, err error) {
	count := 1

	file, err := os.Open(filepath.Clean(filePath))
	if err != nil {
		return 0, myerrors.SysError()
	}
	defer file.Close()

	line, err := ioutil.ReadAll(file)

	pr, rw := io.Pipe()
	go func() {
		for i := 0; i < count; i++ {
			rw.Write(line)
		}
		rw.Close()
	}()
	// 构造request对象
	request, err := http.NewRequest("PUT", url, pr)
	for key, value := range headers {
		request.Header.Add(key, value)
	}

	// 提前计算出ContentLength
	request.ContentLength = int64(len(line) * count)
	resp, _ := http.DefaultClient.Do(request)
	return resp.StatusCode, err
}

// CommitFile 提交文件
func (w *Storage) CommitFile(uploadKey, filename, spaceId, parentId, unionId string) (response CommitFileResponse, err error) {
	optionAppProperties0 := &CommitFileRequestOptionAppProperties{
		Name:       utils.String("System"),
		Value:      utils.String("oms"),
		Visibility: utils.String("PUBLIC"),
	}
	option := &CommitFileRequestOption{
		//Size:             utils.Int64(size),
		ConflictStrategy: utils.String("AUTO_RENAME"),
		AppProperties:    []*CommitFileRequestOptionAppProperties{optionAppProperties0},
	}
	request := &CommitFileRequest{
		UnionId:   utils.String(unionId),
		UploadKey: utils.String(uploadKey),
		Name:      utils.String(filename),
		ParentId:  utils.String(parentId),
		Option:    option,
	}
	resp, err := w.HTTPPostJSONWithAccessToken(fmt.Sprintf(CommitFileUploadInfoUrl, spaceId), request)
	err = json.Unmarshal(resp, &response)
	return response, err
}

func (w *Storage) UploadFile(spaceId, unionId, fileName, filePath string) (response CommitFileResponse, err error) {
	// permResp, err := w.AddPermission(w.CorpId, spaceId, unionId, "EDITOR", "USER")
	// if err != nil {
	// 	return response, myerrors.New(500, err, err.Error())
	// }

	// if !permResp.Success {
	// 	return response, myerrors.New(500, nil, "获取钉钉上传文件权限失败！")
	// }

	infoResp, err := w.QueryFileUploadInfo(spaceId, unionId)
	if err != nil {
		return response, myerrors.New(500, err, err.Error())
	}

	uploadResp, err := w.uploadFile(infoResp.HeaderSignatureInfo.ResourceUrls[0], infoResp.HeaderSignatureInfo.Headers, filePath)
	if err != nil {
		return response, myerrors.New(500, err, err.Error())
	}
	if uploadResp != 200 {
		return response, myerrors.New(500, nil, "文件上传失败！")
	}
	return w.CommitFile(infoResp.UploadKey, fileName, spaceId, "0", unionId)
}