/*
 * Copyright 2025 coze-dev Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package upload

import (
	"bytes"
	"context"
	"encoding/xml"
	"errors"
	"fmt"
	"hash/crc32"
	"image"
	_ "image/gif"
	_ "image/jpeg"
	_ "image/png"
	"io"
	"math"
	"mime"
	"mime/multipart"
	"path"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"time"

	_ "golang.org/x/image/tiff"
	_ "golang.org/x/image/webp"

	"github.com/google/uuid"

	"github.com/coze-dev/coze-studio/backend/api/model/file/upload"
	"github.com/coze-dev/coze-studio/backend/api/model/flow/dataengine/dataset"
	"github.com/coze-dev/coze-studio/backend/api/model/ocean/cloud/developer_api"
	"github.com/coze-dev/coze-studio/backend/api/model/ocean/cloud/playground"
	"github.com/coze-dev/coze-studio/backend/application/base/ctxutil"
	"github.com/coze-dev/coze-studio/backend/domain/upload/entity"
	"github.com/coze-dev/coze-studio/backend/infra/contract/cache"
	"github.com/coze-dev/coze-studio/backend/infra/contract/storage"
	"github.com/coze-dev/coze-studio/backend/pkg/errorx"
	"github.com/coze-dev/coze-studio/backend/pkg/lang/conv"
	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
	"github.com/coze-dev/coze-studio/backend/pkg/logs"
	"github.com/coze-dev/coze-studio/backend/pkg/sonic"
	"github.com/coze-dev/coze-studio/backend/types/consts"
	"github.com/coze-dev/coze-studio/backend/types/errno"
)

func InitService(oss storage.Storage, cache cache.Cmdable) {
	SVC.cache = cache
	SVC.oss = oss
}

var SVC = &UploadService{}

type UploadService struct {
	oss   storage.Storage
	cache cache.Cmdable
}

const (
	uploadKey     = "UploadServiceUpload:%s"
	uploadPartKey = "UploadServiceUpload:%s/parts"
	partKey       = "UploadServiceUpload/%s/part-%s"
)

func (u *UploadService) PartUploadFileInit(ctx context.Context, objKey string) (uploadID string, err error) {
	uploadID = uuid.NewString()
	key := fmt.Sprintf(uploadKey, uploadID)
	err = u.cache.HSet(ctx,
		key,
		"objkey", objKey,
	).Err()
	if err != nil {
		return "", err
	}
	err = u.cache.Expire(ctx, key, time.Minute*10).Err()
	return
}

type PartUploadFileRequest struct {
	UploadID   string
	PartNumber string
	Data       []byte
}

type PartUploadFileResponse struct {
	Crc32 string
}

type PartUploadFileCompleteRequest struct {
	UploadID string
	ObjKey   string
	Crc32Map map[string]string
}

func (u *UploadService) PartUploadFile(ctx context.Context, req *PartUploadFileRequest) (resp *PartUploadFileResponse, err error) {
	key := fmt.Sprintf(uploadKey, req.UploadID)
	exists, err := u.cache.Exists(ctx, key).Result()
	if err != nil || exists == 0 {
		return nil, fmt.Errorf("upload session invalid: %v", err)
	}
	crc32Val := crc32.ChecksumIEEE(req.Data)
	partTosKey := fmt.Sprintf(partKey, req.UploadID, req.PartNumber)
	err = u.oss.PutObject(ctx, partTosKey, req.Data, storage.WithExpires(time.Now().Add(10*time.Minute)))
	if err != nil {
		return nil, err
	}
	partMeta := map[string]interface{}{
		"tos_key": partTosKey,
	}
	partMetaData, err := sonic.Marshal(partMeta)
	if err != nil {
		return nil, err
	}
	partKey := fmt.Sprintf(uploadPartKey, req.UploadID)
	err = u.cache.HSet(ctx, partKey, req.PartNumber, string(partMetaData)).Err()
	if err != nil {
		return nil, err
	}
	err = u.cache.Expire(ctx, partKey, time.Minute*10).Err()
	if err != nil {
		return nil, err
	}
	return &PartUploadFileResponse{
		Crc32: fmt.Sprintf("%08x", crc32Val),
	}, nil
}

type tosPart struct {
	PartNum int
	Data    []byte
}

func getContentType(uri string) (contentType string) {
	_ = mime.AddExtensionType(".svg", "image/svg+xml")
	_ = mime.AddExtensionType(".svgz", "image/svg+xml")
	_ = mime.AddExtensionType(".webp", "image/webp")
	_ = mime.AddExtensionType(".ico", "image/x-icon")
	fileExtension := path.Base(uri)
	ext := path.Ext(fileExtension)
	contentType = mime.TypeByExtension(ext)
	return
}

func (u *UploadService) PartUploadFileComplete(ctx context.Context, req *PartUploadFileCompleteRequest) error {
	partKey := fmt.Sprintf(uploadPartKey, req.UploadID)
	parts, err := u.cache.HGetAll(ctx, partKey).Result()
	if err != nil {
		return err
	}
	tosParts := []*tosPart{}
	for partNumStr, partData := range parts {
		var partMeta map[string]string
		if err := sonic.Unmarshal([]byte(partData), &partMeta); err != nil {
			return fmt.Errorf("failed to parse part metadata: %v", err)
		}
		partNum, err := strconv.ParseInt(partNumStr, 10, 64)
		if err != nil {
			return err
		}
		objKey, exist := partMeta["tos_key"]
		if !exist {
			return errors.New("tos key not exist")
		}
		byteData, err := u.oss.GetObject(ctx, objKey)
		if err != nil {
			return err
		}
		tosParts = append(tosParts, &tosPart{PartNum: int(partNum), Data: byteData})
	}
	if len(tosParts) == 0 {
		return errors.New("tos part is null")
	}
	sort.Slice(tosParts, func(i, j int) bool { return tosParts[i].PartNum < tosParts[j].PartNum })
	if tosParts[len(tosParts)-1].PartNum != len(tosParts) || len(tosParts) != len(req.Crc32Map) {
		return errors.New("check parts fail")
	}
	totalData := []byte{}
	for _, val := range tosParts {
		crc32 := fmt.Sprintf("%08x", crc32.ChecksumIEEE(val.Data))
		crc32Check := req.Crc32Map[strconv.Itoa(val.PartNum)]
		if crc32 != crc32Check {
			return errors.New("crc32 check fail")
		}
		totalData = append(totalData, val.Data...)
	}
	contentType := getContentType(req.ObjKey)
	if len(contentType) != 0 {
		err = u.oss.PutObject(ctx, req.ObjKey, totalData, storage.WithContentType(contentType))
	} else {
		err = u.oss.PutObject(ctx, req.ObjKey, totalData)
	}

	return err
}

func (u *UploadService) GetIcon(ctx context.Context, req *developer_api.GetIconRequest) (
	resp *developer_api.GetIconResponse, err error,
) {
	iconURI := map[developer_api.IconType]string{
		developer_api.IconType_Bot:        consts.DefaultAgentIcon,
		developer_api.IconType_User:       consts.DefaultUserIcon,
		developer_api.IconType_Plugin:     consts.DefaultPluginIcon,
		developer_api.IconType_Dataset:    consts.DefaultDatasetIcon,
		developer_api.IconType_Workflow:   consts.DefaultWorkflowIcon,
		developer_api.IconType_Imageflow:  consts.DefaultPluginIcon,
		developer_api.IconType_Society:    consts.DefaultPluginIcon,
		developer_api.IconType_Connector:  consts.DefaultPluginIcon,
		developer_api.IconType_ChatFlow:   consts.DefaultPluginIcon,
		developer_api.IconType_Voice:      consts.DefaultPluginIcon,
		developer_api.IconType_Enterprise: consts.DefaultTeamIcon,
	}

	uri := iconURI[req.GetIconType()]
	if uri == "" {
		return nil, errorx.New(errno.ErrUploadInvalidType,
			errorx.KV("type", conv.Int64ToStr(int64(req.GetIconType()))))
	}

	url, err := u.oss.GetObjectUrl(ctx, iconURI[req.GetIconType()])
	if err != nil {
		return nil, err
	}

	return &developer_api.GetIconResponse{
		Data: &developer_api.GetIconResponseData{
			IconList: []*developer_api.Icon{
				{
					URL: url,
					URI: uri,
				},
			},
		},
	}, nil
}
func stringToMap(input string) map[string]string {
	result := make(map[string]string)

	pairs := strings.Split(input, ",")

	for _, pair := range pairs {
		parts := strings.Split(pair, ":")
		if len(parts) == 2 {
			key := strings.TrimSpace(parts[0])
			value := strings.TrimSpace(parts[1])
			result[key] = value
		}
	}

	return result
}
func (u *UploadService) UploadFileCommon(ctx context.Context, req *upload.CommonUploadRequest, fullPath string) (*upload.CommonUploadResponse, error) {
	resp := upload.NewCommonUploadResponse()
	re := regexp.MustCompile(consts.UploadURI + `/([^?]+)`)
	match := re.FindStringSubmatch(fullPath)
	if len(match) == 0 {
		return nil, errorx.New(errno.ErrUploadInvalidParamCode, errorx.KV("msg", "tos key not found"))
	}
	objKey := match[1]
	if strings.Contains(fullPath, "?uploads") {
		uploadID, err := u.PartUploadFileInit(ctx, objKey)
		if err != nil {
			return resp, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", err.Error()))
		}
		resp.Error = &upload.Error{Code: 200}
		resp.Payload = &upload.Payload{UploadID: uploadID}
		return resp, nil
	}
	if len(ptr.From(req.PartNumber)) != 0 {
		_, err := u.PartUploadFile(ctx, &PartUploadFileRequest{
			UploadID:   ptr.From(req.UploadID),
			PartNumber: ptr.From(req.PartNumber),
			Data:       req.ByteData,
		})
		if err != nil {
			return resp, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", err.Error()))
		}
		resp.Error = &upload.Error{Code: 200}
		return resp, nil
	}
	if len(ptr.From(req.UploadID)) != 0 {
		mp := stringToMap(string(req.ByteData))
		err := u.PartUploadFileComplete(ctx, &PartUploadFileCompleteRequest{
			UploadID: ptr.From(req.UploadID),
			ObjKey:   objKey,
			Crc32Map: mp,
		})
		if err != nil {
			return resp, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", err.Error()))
		}
		resp.Error = &upload.Error{Code: 200}
		resp.Payload = &upload.Payload{Key: uuid.NewString()}
		return resp, nil
	}
	var err error
	contentType := getContentType(objKey)
	if len(contentType) != 0 {
		err = u.oss.PutObject(ctx, objKey, req.ByteData, storage.WithContentType(contentType))
	} else {
		err = u.oss.PutObject(ctx, objKey, req.ByteData)
	}
	if err != nil {
		return resp, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", err.Error()))
	}
	resp.Error = &upload.Error{Code: 200}
	resp.Payload = &upload.Payload{Key: uuid.NewString()}
	return resp, err
}

func (u *UploadService) UploadFile(ctx context.Context, data []byte, objKey string) (*developer_api.UploadFileResponse, error) {
	err := u.oss.PutObject(ctx, objKey, data)
	if err != nil {
		return nil, err
	}

	url, err := u.oss.GetObjectUrl(ctx, objKey)
	if err != nil {
		return nil, err
	}

	return &developer_api.UploadFileResponse{
		Data: &developer_api.UploadFileData{
			UploadURL: url,
			UploadURI: objKey,
		},
	}, nil
}

func (u *UploadService) GetShortcutIcons(ctx context.Context) ([]*playground.FileInfo, error) {
	shortcutIcons := entity.GetDefaultShortcutIconURI()
	fileList := make([]*playground.FileInfo, 0, len(shortcutIcons))
	for _, uri := range shortcutIcons {
		url, err := u.oss.GetObjectUrl(ctx, uri)
		if err == nil {
			fileList = append(fileList, &playground.FileInfo{
				URL: url,
				URI: uri,
			})
		}
	}
	return fileList, nil
}

func parseMultipartFormData(ctx context.Context, req *playground.UploadFileOpenRequest) (*multipart.Form, error) {
	_, params, err := mime.ParseMediaType(req.ContentType)
	if err != nil {
		return nil, errorx.New(errno.ErrUploadInvalidContentTypeCode, errorx.KV("content-type", req.ContentType))
	}
	br := bytes.NewReader(req.Data)
	mr := multipart.NewReader(br, params["boundary"])

	form, err := mr.ReadForm(maxFileSize)
	if errors.Is(err, multipart.ErrMessageTooLarge) {
		return nil, errorx.New(errno.ErrUploadInvalidFileSizeCode)
	} else if err != nil {
		return nil, errorx.New(errno.ErrUploadMultipartFormDataReadFailedCode)
	}
	return form, nil
}

func genObjName(name string, id string) string {

	return fmt.Sprintf("%s/%s/%s",
		"bot_files",
		id,
		name,
	)
}

func (u *UploadService) UploadFileOpen(ctx context.Context, req *playground.UploadFileOpenRequest) (*playground.UploadFileOpenResponse, error) {
	resp := playground.UploadFileOpenResponse{}
	resp.File = new(playground.File)
	uid := ctxutil.MustGetUIDFromApiAuthCtx(ctx)
	if uid == 0 {
		return nil, errorx.New(errno.ErrKnowledgePermissionCode, errorx.KV("msg", "session required"))
	}
	form, err := parseMultipartFormData(ctx, req)
	if err != nil {
		logs.CtxErrorf(ctx, "parse multipart form data failed, err: %v", err)
		return nil, err
	}
	if len(form.File["file"]) == 0 {
		return nil, errorx.New(errno.ErrUploadEmptyFileCode)
	} else if len(form.File["file"]) > 1 {
		return nil, errorx.New(errno.ErrUploadFileUploadGreaterOneCode)
	}
	fileHeader := form.File["file"][0]

	// open file
	file, err := fileHeader.Open()
	if err != nil {
		return nil, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", "fileHeader open failed"))
	}
	defer file.Close()
	data, err := io.ReadAll(file)
	if err != nil {
		return nil, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", "file upload io read failed"))
	}
	resp.File.Bytes = int64(len(data))
	randID := uuid.NewString()
	objName := genObjName(fileHeader.Filename, randID)
	resp.File.FileName = fileHeader.Filename
	resp.File.URI = objName
	err = u.oss.PutObject(ctx, objName, data)
	if err != nil {
		return nil, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", "file upload to oss failed"))
	}
	url, err := u.oss.GetObjectUrl(ctx, objName)
	if err != nil {
		return nil, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", "get object url failed"))
	}
	resp.File.CreatedAt = time.Now().Unix()
	resp.File.URL = url
	return &resp, nil
}

func (u *UploadService) GetIconForDataset(ctx context.Context, req *dataset.GetIconRequest) (*dataset.GetIconResponse, error) {
	resp := dataset.NewGetIconResponse()
	var uri string
	switch req.FormatType {
	case dataset.FormatType_Text:
		uri = TextKnowledgeDefaultIcon
	case dataset.FormatType_Table:
		uri = TableKnowledgeDefaultIcon
	case dataset.FormatType_Image:
		uri = ImageKnowledgeDefaultIcon
	case dataset.FormatType_Database:
		uri = DatabaseDefaultIcon
	default:
		uri = TextKnowledgeDefaultIcon
	}

	iconUrl, err := u.oss.GetObjectUrl(ctx, uri)
	if err != nil {
		return resp, err
	}
	resp.Icon = &dataset.Icon{
		URL: iconUrl,
		URI: uri,
	}
	return resp, nil
}

func (u *UploadService) UploadSessionKey(ctx context.Context, sessionKey string, tosKey string) error {
	return u.cache.Set(ctx, sessionKey, tosKey, time.Minute*30).Err()
}

type GetObjInfoBySessionKey struct {
	ObjKey string
	Width  int32
	Height int32
}

func isImageUri(uri string) bool {
	if uri == "" {
		return false
	}
	uri = strings.ToLower(uri)
	fileExtension := path.Base(uri)
	ext := path.Ext(fileExtension)
	ext = ext[1:]
	imageExtensions := map[string]bool{
		"jpg":  true,
		"jpeg": true,
		"png":  true,
		"gif":  true,
		"bmp":  true,
		"webp": true,
		"tiff": true,
		"svg":  true,
		"ico":  true,
	}

	// 检查扩展名是否在图片扩展名列表中
	return imageExtensions[ext]
}
func (u *UploadService) GetObjInfoBySessionKey(ctx context.Context, sessionKey string) (*GetObjInfoBySessionKey, error) {
	resp := GetObjInfoBySessionKey{}
	objKey, err := u.cache.Get(ctx, sessionKey).Result()
	if err != nil {
		return nil, err
	}
	resp.ObjKey = objKey
	if isImageUri(objKey) {
		content, err := u.oss.GetObject(ctx, objKey)
		if err != nil {
			return nil, err
		}
		if isSVG(objKey) {
			width, height, err := getSVGDimensions(content)
			if err != nil {
				logs.CtxErrorf(ctx, "get svg dimensions failed, err: %v", err)
				// default val
				resp.Width = 100
				resp.Height = 100
				return &resp, nil
			}
			resp.Width = width
			resp.Height = height
		} else {
			img, _, err := image.Decode(bytes.NewReader(content))
			if err != nil {
				logs.CtxErrorf(ctx, "decode image failed, err: %v", err)
				// default val
				resp.Width = 100
				resp.Height = 100
				return &resp, nil
			}
			resp.Width = int32(img.Bounds().Dx())
			resp.Height = int32(img.Bounds().Dy())
		}
	}
	return &resp, nil
}

type SVG struct {
	Width   string `xml:"width,attr"`
	Height  string `xml:"height,attr"`
	ViewBox string `xml:"viewBox,attr"`
}

// 获取 SVG 尺寸
func getSVGDimensions(content []byte) (width, height int32, err error) {
	decoder := xml.NewDecoder(bytes.NewReader(content))

	var svg SVG
	if err := decoder.Decode(&svg); err != nil {
		return 100, 100, nil
	}

	// 尝试从width属性获取
	if svg.Width != "" {
		w, err := parseDimension(svg.Width)
		if err == nil {
			width = w
		}
	}

	// 尝试从height属性获取
	if svg.Height != "" {
		h, err := parseDimension(svg.Height)
		if err == nil {
			height = h
		}
	}

	// 如果width或height未设置，尝试从viewBox获取
	if width == 0 || height == 0 {
		if svg.ViewBox != "" {
			parts := strings.Fields(svg.ViewBox)
			if len(parts) >= 4 {
				if width == 0 {
					w, err := strconv.ParseInt(parts[2], 10, 32)
					if err == nil {
						width = int32(w)
					}
				}
				if height == 0 {
					h, err := strconv.ParseInt(parts[3], 10, 32)
					if err == nil {
						height = int32(h)
					}
				}
			}
		}
	}

	if width == 0 || height == 0 {
		return 100, 100, nil
	}

	return width, height, nil
}
func parseDimension(dim string) (int32, error) {
	// 去除单位(px, pt, em, %等)和空格
	dim = strings.TrimSpace(dim)
	dim = strings.TrimRightFunc(dim, func(r rune) bool {
		return (r < '0' || r > '9') && r != '.' && r != '-' && r != '+'
	})

	// 解析为float64
	value, err := strconv.ParseFloat(dim, 64)
	if err != nil {
		return 0, err
	}

	// 四舍五入转换为int32
	if value > math.MaxInt32 {
		return math.MaxInt32, nil
	}
	if value < math.MinInt32 {
		return math.MinInt32, nil
	}
	return int32(math.Round(value)), nil
}
func isSVG(uri string) bool {
	uri = strings.ToLower(uri)
	fileExtension := path.Base(uri)
	ext := path.Ext(fileExtension)
	ext = ext[1:]
	return ext == "svg"
}
func (u *UploadService) ApplyImageUpload(ctx context.Context, req *upload.ApplyUploadActionRequest, host string) (*upload.ApplyUploadActionResponse, error) {
	resp := upload.ApplyUploadActionResponse{}
	storeUri := "tos-cn-i-v4nquku3lp/" + uuid.NewString() + ptr.From(req.FileExtension)
	sessionKey := uuid.NewString()
	auth := uuid.NewString()
	uploadID := uuid.NewString()
	uploadHost := string(host) + consts.UploadURI
	resp.ResponseMetadata = &upload.ResponseMetadata{
		RequestId: uuid.NewString(),
		Action:    "ApplyImageUpload",
		Version:   "",
		Service:   "",
		Region:    "",
	}
	resp.Result = &upload.ApplyUploadActionResult{
		UploadAddress: &upload.UploadAddress{
			StoreInfos: []*upload.StoreInfo{
				{
					StoreUri: storeUri,
					Auth:     auth,
					UploadID: uploadID,
				},
			},
			UploadHosts: []string{uploadHost},
			SessionKey:  sessionKey,
		},
		InnerUploadAddress: &upload.InnerUploadAddress{
			UploadNodes: []*upload.UploadNode{
				{
					StoreInfos: []*upload.StoreInfo{
						{
							StoreUri: storeUri,
							Auth:     auth,
							UploadID: uploadID,
						},
					},
					UploadHost: uploadHost,
					SessionKey: sessionKey,
				},
			},
		},
		RequestId: ptr.Of(uuid.NewString()),
	}
	err := u.UploadSessionKey(ctx, sessionKey, storeUri)
	if err != nil {
		return &resp, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", err.Error()))
	}
	return &resp, nil
}

func (u *UploadService) CommitImageUpload(ctx context.Context, req *upload.ApplyUploadActionRequest, host string) (*upload.ApplyUploadActionResponse, error) {
	resp := upload.ApplyUploadActionResponse{}
	type ssKey struct {
		SessionKey string `json:"SessionKey"`
	}
	sskey := ssKey{}
	err := sonic.Unmarshal(req.ByteData, &sskey)
	if err != nil {
		return &resp, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", err.Error()))
	}
	objInfo, err := u.GetObjInfoBySessionKey(ctx, sskey.SessionKey)
	if err != nil {
		return &resp, errorx.New(errno.ErrUploadSystemErrorCode, errorx.KV("msg", err.Error()))
	}
	resp.ResponseMetadata = &upload.ResponseMetadata{
		RequestId: uuid.NewString(),
		Action:    "ApplyImageUpload",
		Version:   "",
		Service:   "",
		Region:    "",
	}
	resp.Result = &upload.ApplyUploadActionResult{
		Results: []*upload.UploadResult{
			{
				Uri:       objInfo.ObjKey,
				UriStatus: 2000,
			},
		},
		RequestId: ptr.Of(uuid.NewString()),
		PluginResult: []*upload.PluginResult{
			{
				FileName:    objInfo.ObjKey,
				SourceUri:   objInfo.ObjKey,
				ImageUri:    objInfo.ObjKey,
				ImageWidth:  objInfo.Width,
				ImageHeight: objInfo.Height,
			},
		},
	}

	return &resp, nil
}