package service

import (
	"StuAcaWorksAI/dao"
	"StuAcaWorksAI/proto"
	"StuAcaWorksAI/worker"
	"crypto/md5"
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"io"
	"log"
	"mime/multipart"
	"os"
	"path"
	"regexp"
	"strings"
	"time"
)

// 检查path是否存在当前日期文件夹如（2024-08-09），不存在则path下当前日期文件夹创建，存在则返回
func GetFilePath(path string) string {
	//当前日期，格式为2024-08-09
	date := time.Now().Format("2006-01-02")
	//拼接文件路径
	filePath := path + "/" + date
	//判断文件夹是否存在
	_, err := os.Stat(filePath)
	if err != nil {
		//不存在则创建
		os.MkdirAll(filePath, os.ModePerm)
	}
	return filePath
}

func SaveFile(c *gin.Context, file *multipart.FileHeader, uploadType string) (string, string, error) {
	//获取文件后缀
	fileSuffix := path.Ext(file.Filename)
	//生成文件名
	fileStoreName := uuid.NewString() + fileSuffix
	//生成文件路径
	path_ := GetFilePath(proto.FILE_BASE_DIR)
	filePath := path_ + "/" + fileStoreName
	//保存文件
	if err := c.SaveUploadedFile(file, filePath); err != nil {
		return "", "", err
	}
	if uploadType == "2" {
		worker.PushRedisList("video_need_handle", filePath)
	}

	return path_, fileStoreName, nil
}

func CalculateFileMd5(file io.Reader) string {
	hash := md5.New()
	if _, err := io.Copy(hash, file); err != nil {
		return ""
	}
	return fmt.Sprintf("%x", hash.Sum(nil))
}

func CheckUploadRequestParameters(req *proto.FileUploadReq) error {
	var err error
	if req.AuthType == "" {
		err = fmt.Errorf("auth_type is empty")
	}
	if req.UploadType == "" {
		req.UploadType = "1"
	}
	if req.UploadType != "1" {
		req.UploadType = "2"
	}
	if proto.File_Type[req.Type] == 0 {
		err = fmt.Errorf("file type is invalid")
	}
	return err
}

func CreateConfigFile(req *proto.AddConfigFileReq, userId int) error {
	var err error
	user := GetUserByIDWithCache(userId)
	if user.ID == 0 || user.Role != "admin" {
		err = fmt.Errorf("user not found or no permission")
		return err
	}
	if req.FileName == "" || req.FilePath == "" {
		err = fmt.Errorf("file name or file path is empty")
		return err
	}
	//查看系统中是否存在文件,不存在则创建
	file := req.FilePath + "/" + req.FileName
	//正则判断文件名是否合法
	pattern := `^/([^/:\*?]+/)*([^/:\*?]+)?$`
	reg := regexp.MustCompile(pattern)
	if reg.MatchString(file) == false {
		err = fmt.Errorf("file path is invalid")
		return err
	}
	_, fileErr := os.Stat(file)
	if fileErr != nil {
		//创建文件
		f, err2 := os.Create(file)
		if err2 != nil {
			err = err2
			return err
		}
		defer func(f *os.File) {
			err := f.Close()
			if err != nil {
				fmt.Println("Error closing file")
			}
		}(f)
	}
	//创建
	configFile := dao.ConfigFile{FilePath: req.FilePath, FileName: req.FileName, AuthID: userId}
	_, err3 := dao.CreateConfigFile(configFile)
	if err3 != nil {
		err = err3
		return err
	}
	return err
}

func DeleteConfigFile(req *proto.ConfigFileReq, userId int) error {
	var err error
	user := GetUserByIDWithCache(userId)
	if user.ID == 0 || user.Role != "admin" {
		err = fmt.Errorf("user not found or no permission")
		return err
	}
	//删除文件
	config_file := dao.FindConfigFileByID(req.ID, userId)
	if config_file.ID == 0 {
		err = fmt.Errorf("config file not found")
		return err
	}
	err = dao.DeleteConfigFileByID(req.ID)
	if req.DelFile {
		file := config_file.FilePath + "/" + config_file.FileName
		err = os.Remove(file)
		if err != nil {
			return err
		}
	}
	//删除数据库记录
	return err
}

type ConfigFileService struct {
}

func (c *ConfigFileService) UpdateConfigFile(req *proto.ConfigFileReq, userId int) error {
	var err error
	user := GetUserByIDWithCache(userId)
	if user.ID == 0 || user.Role != "admin" {
		err = fmt.Errorf("user not found or no permission")
		return err
	}
	config_file := dao.FindConfigFileByID(req.ID, userId)
	if config_file.ID == 0 {
		err = fmt.Errorf("config file not found")
		return err
	}
	//修改文件名
	if req.FileName != "" {
		file := config_file.FilePath + "/" + config_file.FileName
		new_file := config_file.FilePath + "/" + req.FileName
		err = os.Rename(file, new_file)
		if err != nil {
			return err
		}
		err = dao.UpdateConfigFileByID(req.ID, dao.ConfigFile{FileName: req.FileName})
	}
	if req.Content != "" {
		file := config_file.FilePath + "/" + config_file.FileName
		f, err2 := os.OpenFile(file, os.O_WRONLY|os.O_TRUNC, 0644) //打开文件，清空文件内容，写入新内容，不存在则创建
		if err2 != nil {
			err = err2
			return err
		}
		defer func(f *os.File) {
			err3 := f.Close()
			if err3 != nil {
				fmt.Println("Error closing file")
			}
		}(f)
		_, err = f.WriteString(req.Content)
		if err != nil {
			return err
		}
	}
	return err
}

func (c *ConfigFileService) SearchOneConfigFile(req *proto.ConfigFileReq, userId int) ([]proto.SearchOneConfigFileResp, error) {
	user := GetUserByIDWithCache(userId)
	if user.ID == 0 || user.Role != "admin" {
		return []proto.SearchOneConfigFileResp{}, fmt.Errorf("user not found or no permission")
	}
	config_file := dao.FindConfigFileByID(req.ID, userId)
	if config_file.ID == 0 {
		return []proto.SearchOneConfigFileResp{}, fmt.Errorf("config file not found")
	}
	file := config_file.FilePath + "/" + config_file.FileName
	content, err2 := os.ReadFile(file)
	if err2 != nil {
		return []proto.SearchOneConfigFileResp{}, err2
	}
	resp := []proto.SearchOneConfigFileResp{{ID: config_file.ID, FilePath: config_file.FilePath, FileName: config_file.FileName, Content: string(content), CreatedAt: config_file.CreatedAt, UpdatedAt: config_file.UpdatedAt}}
	return resp, nil
}

func (c *ConfigFileService) SearchAllConfigFile(userId int) ([]dao.ConfigFile, error) {
	user := GetUserByIDWithCache(userId)
	if user.ID == 0 || user.Role != "admin" {
		return []dao.ConfigFile{}, fmt.Errorf("user not found or no permission")
	}
	config_files := dao.FindConfigFileByAuthID(userId)
	return config_files, nil
}

func UpdateUserFile(userID int, fileAuthID int, fileAuthName string) error {
	fileAuth := dao.FindFileAuthByID(fileAuthID)
	if fileAuth.ID == 0 {
		return errors.New("file auth not found")
	}
	if fileAuth.AuthID != userID {
		return errors.New("no permission")
	}
	fileAuth.UserFileName = fileAuthName
	err := dao.UpdateFileAuthByID(fileAuthID, fileAuth)
	return err
}
func DeleteUserFile(userID, fileAuthID int) error {
	fileAuth := dao.FindFileAuthByID(fileAuthID)
	if fileAuth.ID == 0 {
		return errors.New("file auth not found")
	}
	if fileAuth.AuthID != userID {
		return errors.New("no permission")
	}
	err := dao.DeleteFileAuthByID(fileAuthID)
	return err
}

func CreateUserFile(userID int, fileAuthName string, fileID int, UploadType string) dao.FileAuth {
	//先查fileAuthName是否存在
	fileAuth := dao.FindFileAuthByName(fileAuthName, userID)
	if fileAuth.ID != 0 {
		log.Println("file auth name already exist, please change another name: ", fileAuthName)
		//将要保存的文件名改为fileAuthName+uuid
		strs := strings.Split(fileAuth.UserFileName, ".")
		//当前时间戳
		timestamp := time.Now().Unix()
		timestampStr := fmt.Sprintf("%d", timestamp)
		fileAuthName = strs[0] + "_" + timestampStr + "." + strs[1]
		//return fileAuth
	}
	fileAuth_ := dao.CreateFileAuth(userID, fileID, fileAuthName, UploadType, 1, "")
	return fileAuth_
}

func FindUserFileList(userID int, uploadType string) []dao.UserFileListResp {
	fileList, files := dao.FileUserFileList(userID, uploadType)
	filesM := make(map[uint]dao.File)
	for _, file := range files {
		filesM[file.ID] = file
	}
	var res []dao.UserFileListResp
	for _, file := range fileList {
		fileStoreName := filesM[uint(file.FileID)].FileStoreName
		r := dao.UserFileListResp{FileAuth: file, FileStoreName: fileStoreName}
		res = append(res, r)
	}
	log.Println("FindUserFileList res:", len(res))
	return res
}

func CreateUserFileAfterUnique() {

}

func FindFileContent(userID int, userReq *proto.FileContentReq) ([]dao.FileContent, error) {
	fileAuth := dao.FindFileAuthByID(userReq.UserFileID)
	if fileAuth.ID == 0 {
		return nil, errors.New("file auth not found")
	}
	if fileAuth.AuthID != userID {
		return nil, errors.New("no permission")
	}
	//获取文件基础信息
	file := dao.FindFileByID(fileAuth.FileID, userID)
	//判断文件类型\
	fileType := strings.Split(file.FileStoreName, ".")[1]
	//如果文件类型是图片
	if fileType == "jpg" || fileType == "png" || fileType == "jpeg" || fileType == "gif" {
		return nil, errors.New("file type is image")
	}
	//获取文件内容
	fileContents := dao.FindFileContentByFileID(fileAuth.FileID)
	if len(fileContents) == 0 {
		//直接读取文件内容
		filePath := file.FilePath + "/" + file.FileStoreName
		fileContentStr, err := readFileContent(filePath)
		if err != nil {
			return nil, err
		}
		var fileContent dao.FileContent
		fileContent.FileID = -1
		fileContent.FileContent = fileContentStr
		fileContents = append(fileContents, fileContent)
	}
	return fileContents, nil
}

func CreateFileContent(userID, fileID int, fileContent string) (uint, error) {
	user := GetUserByIDWithCache(userID)
	if user.Role != "admin" {
		return 0, errors.New("no permission")
	}
	//查找文件是否存在
	fileContentC, err := dao.FindFileContentByFileIDAndContentID(fileID)
	if err != nil {
		return 0, err
	}
	//如果文件存在,则更新文件内容
	if fileContentC.ID != 0 {
		return dao.UpdateFileContentByID(fileContentC.ID, fileContent)
	}
	return dao.CreateFileContent(fileID, fileContent)
}

func GetFileWillConvertContentFileList(userID int) ([]dao.File, error) {
	user := GetUserByIDWithCache(userID)
	if user.Role != "admin" {
		return nil, errors.New("no permission")
	}
	files, err2 := dao.GetFileWillConvertContentFileList()
	if err2 != nil {
		return nil, err2
	}
	var res []dao.File
	for _, file := range files {
		fileType := strings.Split(file.FileStoreName, ".")[1]
		//如果文件类型是图片则不需要返回
		if fileType == "jpg" || fileType == "png" || fileType == "jpeg" || fileType == "gif" {
			continue
		}
		//如果文件类型是视频则不需要返回
		if fileType == "mp4" || fileType == "avi" || fileType == "rmvb" || fileType == "mkv" {
			continue
		}
		//如果文件类型是音频则不需要返回
		if fileType == "mp3" || fileType == "wav" || fileType == "wma" {
			continue
		}
		//如果文件类型是压缩包则不需要返回
		if fileType == "zip" || fileType == "rar" || fileType == "7z" {
			continue
		}
		res = append(res, file)
	}
	return res, nil
}
func readFileContent(filePath string) (string, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return "", err
	}
	defer file.Close()

	content, err := io.ReadAll(file)
	if err != nil {
		return "", err
	}

	return string(content), nil
}

func FindFileContentV2(fileID, userID int) ([]dao.FileContent, error) {
	//获取文件基础信息
	file := dao.FindFileByID(fileID, userID)
	//判断文件类型\
	fileType := strings.Split(file.FileStoreName, ".")[1]
	//如果文件类型是图片
	if fileType == "jpg" || fileType == "png" || fileType == "jpeg" || fileType == "gif" {
		return nil, errors.New("file type is image")
	}
	//获取文件内容
	fileContents := dao.FindFileContentByFileID(fileID)
	if len(fileContents) == 0 {
		//直接读取文件内容
		filePath := file.FilePath + "/" + file.FileStoreName
		fileContentStr, err := readFileContent(filePath)
		if err != nil {
			return nil, err
		}
		var fileContent dao.FileContent
		fileContent.FileID = -1
		fileContent.FileContent = fileContentStr
		fileContents = append(fileContents, fileContent)
	}
	return fileContents, nil
}

func FindImageFileContent(fileID, userID int) (string, error) {
	//获取文件基础信息
	file := dao.FindFileByID(fileID, userID)
	//判断文件类型\
	fileType := strings.Split(file.FileStoreName, ".")[1]
	//如果文件类型是图片
	if fileType != "jpg" && fileType != "png" && fileType != "jpeg" && fileType != "gif" {
		return "", errors.New("file type is not image")
	}
	//直接读取文件内容
	filePath := file.FilePath + "/" + file.FileStoreName
	base64Str, err := readImageFile(filePath)
	if err != nil {
		return "", err
	}
	return base64Str, nil
}

// readImageFile 函数用于读取指定路径的图片文件并将其内容转换为 Base64 编码字符串
func readImageFile(filePath string) (string, error) {
	// 打开图片文件
	file, err := os.Open(filePath)
	if err != nil {
		return "", fmt.Errorf("无法打开文件: %w", err)
	}
	// 确保文件在函数结束时关闭
	defer file.Close()

	// 读取图片文件内容
	imageData, err := io.ReadAll(file)
	if err != nil {
		return "", fmt.Errorf("无法读取文件内容: %w", err)
	}

	// 将图片数据进行 Base64 编码
	base64Encoded := base64.StdEncoding.EncodeToString(imageData)
	return base64Encoded, nil
}