package coryCommon

import (
	"archive/zip"
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"fmt"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
)

//解压文件、文件夹复制

// FileZipFunc 对文件进行解压
func FileZipFunc(relativePath string, filenPath string, template string) (fileName string, err error) {
	// 打开压缩文件
	zipFile, err := zip.OpenReader(relativePath)
	if err != nil {
		fmt.Println("无法打开压缩文件（只支持ZIP）:", err)
		return
	}
	var i = 0
	var name = ""
	//进入的压缩文件，判断压缩文件中的第一层是否包含文件，如果有就在当前随机产生一个文件夹，返回就返回到随机文件夹的位置
	randomFolder := ""
	// 遍历压缩文件中的文件头信息
	for _, f := range zipFile.File {
		//path, _ := gbkDecode(f.Name)
		fmt.Println("头？      ", f.Name)
		path, _ := IsGB18030(f.Name)
		// 判断是否为顶层文件夹
		if !hasSlash(path) {
			randomFolder = FileName("/randomFolder")
			template = template + randomFolder
			filenPath = filenPath + randomFolder
			break
		}
	}
	// 遍历压缩文件中的文件
	for _, file := range zipFile.File {
		fmt.Println("ti   ？      ", file.Name)
		// 解决文件名编码问题
		if i == 0 {
			gb18030, _ := IsGB18030(file.Name)
			if err != nil {
				return "", err
			}
			name = gb18030
		}
		file.Name, err = IsGB18030(file.Name)
		if err != nil {
			return "", err
		}
		//对所有文件的名称进行空格替换
		file.Name = strings.Replace(file.Name, " ", "", -1)
		if err != nil {
			return file.Name, err
		}
		// 获取文件的相对路径,根据原本路径来操作还是根据新路径来（filenPath）
		extractedFilePath := ""
		extractedFilePathTwo := ""
		if filenPath != "" {
			extractedFilePath = filepath.Join(FileToFunc(filenPath, 2), "/"+file.Name)
			split := strings.Split(filenPath, "/")
			extractedFilePathTwo = extractedFilePath + "/" + split[len(split)-1]
		} else {
			extractedFilePath = filepath.ToSlash(filepath.Join(GetCWD()+template+"/"+".", file.Name))
			extractedFilePathTwo = extractedFilePath + "/"
		}
		//判断文件夹是否存在，存在就退出（i==0 是为了只判断最外层那一文件夹路径）
		_, err := os.Stat(filepath.Dir(extractedFilePathTwo))
		if err == nil && i == 0 {
			zipFile.Close()
			// 删除压缩文件
			err = os.Remove(relativePath)
			err = errors.New("当前文件夹已经存在，导入无效！")
			return "", err
		}
		i = i + 1
		// 检查是否为文件
		if !file.FileInfo().IsDir() {
			// 创建文件的目录结构
			err = os.MkdirAll(filepath.Dir(extractedFilePath), os.ModePerm)
			if err != nil {
				fmt.Println("无法创建目录:", err)
				return "", err
			}

			// 打开压缩文件中的文件
			zippedFile, err := file.Open()
			if err != nil {
				fmt.Println("无法打开压缩文件中的文件:", err)
				return "", err
			}
			defer zippedFile.Close()

			// 创建目标文件
			extractedFile, err := os.Create(extractedFilePath)

			if err != nil {
				fmt.Println("无法创建目标文件:", err)
				return "", err
			}
			defer extractedFile.Close()

			// 将压缩文件中的内容复制到目标文件
			_, err = io.Copy(extractedFile, zippedFile)
			if err != nil {
				fmt.Println("无法解压缩文件:", err)
				return "", err
			}
		}
	}

	zipFile.Close()

	// 删除压缩文件
	err = os.Remove(relativePath)
	if err != nil {
		fmt.Println("无法删除压缩文件:", err)
		return
	}
	fileName = strings.Split(name, "/")[0]
	if randomFolder != "" {
		fileName = ""
	} else {
		fileName = "/" + fileName
	}
	if filenPath != "" {
		return FileToFunc(filenPath, 2) + fileName, err
	} else {
		return GetCWD() + template + fileName, err
	}
}

// IsGB18030 判断字符串是否是 GB18030 编码
func IsGB18030(name string) (string, error) {
	// 创建 GB18030 解码器
	decoder := simplifiedchinese.GB18030.NewDecoder()
	// 使用 transform 解码数据
	_, err := io.ReadAll(transform.NewReader(bytes.NewReader([]byte(name)), decoder))
	if err == nil {
		return name, nil
	} else {
		fileName, errName := simplifiedchinese.GB18030.NewDecoder().String(name)
		return fileName, errName
	}
}

// gbkDecode 解决文件名乱码
func gbkDecode(s string) (string, error) {
	gbkDecoder := simplifiedchinese.GBK.NewDecoder()
	decodedName, _, err := transform.String(gbkDecoder, s)
	return decodedName, err
}

type DocumentListPublicRes struct {
	Id              int64       `json:"id"`
	IdStr           string      `json:"idStr"`
	Pid             string      `json:"pid"`
	Name            string      `json:"name"`
	FilenPath       string      `json:"filenPath"`
	FilenPathCoding string      `json:"filenPathCoding"`
	Suffix          string      `json:"suffix"`
	Type            string      `json:"type"`
	CreateBy        string      `json:"createBy"`
	CreatedAt       *gtime.Time `json:"createdAt"`
	IsDuplicate     bool        `json:"isDuplicate"`
	ProjectId       int64       `json:"projectId"`
}

// Traversal 遍历文件夹 ctx，绝对路径，上级文件夹（可有可无），表名，存储位置,项目id,模板1or资料2
//
//	one, err := coryCommon.Traversal(ctx, path, req.Pid, dao.DocumentCompletion.Table(), dataFolder, req.ProjectId, "2") //遍历解压后的文件，插入数据
//	if err != nil {
//		liberr.ErrIsNil(ctx, err)
//		return
//	}
//	_, err = g.DB().Model(dao.DocumentCompletion.Table()).Ctx(ctx).Insert(one)
//	liberr.ErrIsNil(ctx, err, "新增失败！")
func Traversal(ctx context.Context, root string, pidstr string, tableName string, templatePath string, projectId int64, num string) (dataOne []*DocumentListPublicRes, err error) {

	template := strings.Replace(templatePath, "/resource/public", "/file", 1)
	err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		// 获取相对路径
		relativePath, err := filepath.Rel(root, path)
		if err != nil {
			return err
		}
		// 根目录下创建，还是指定文件夹下面创建？
		p := ""
		if pidstr != "" {
			value, _ := g.DB().Model(tableName).Ctx(ctx).Where("id_str", pidstr).Fields("filen_path").Value()
			split := strings.Split(root, "/")
			p = value.String() + "/" + split[len(split)-1] + "/" + relativePath
		} else {
			p = template + "/" + relativePath
		}
		p = strings.ReplaceAll(p, "\\", "/")
		// 获取当前项的深度
		depth := strings.Count(relativePath, string(filepath.Separator))
		// 判断父子关系并打印结果
		if depth == 0 && info.IsDir() {
			if relativePath == "." {
				split := strings.Split(root, "/")
				n := split[len(split)-1]
				// 根目录下创建，还是指定文件夹下面创建？
				p := ""
				if pidstr != "" {
					value, _ := g.DB().Model(tableName).Ctx(ctx).Where("id_str", pidstr).Fields("filen_path").Value()
					p = value.String() + "/" + n
				} else {
					p = template + "/" + n
				}
				p = strings.ReplaceAll(p, "\\", "/")
				template = template + "/" + n
				var dataTwo = new(DocumentListPublicRes)
				dataTwo.IdStr = SHA256(p)
				if pidstr != "" {
					dataTwo.Pid = pidstr
				} else {
					dataTwo.Pid = "0"
				}
				dataTwo.Name = n
				dataTwo.FilenPath = p
				////如果文件夹路径重复，就提示   解压文件夹的时候就已经判断了，这里就不需要了
				//err := IsFolderExist(ctx, p)
				//if err != nil {
				//	return err
				//}
				dataTwo.Type = "2"
				dataOne = append(dataOne, dataTwo)
			} else {
				dir, n := filepath.Split(p)
				dir = strings.TrimSuffix(dir, "/")
				var dataTwo = new(DocumentListPublicRes)
				dataTwo.IdStr = SHA256(p)
				dataTwo.Pid = SHA256(dir)
				dataTwo.Name = n
				dataTwo.FilenPath = p
				////如果文件夹路径重复，就提示
				//err := IsFolderExist(ctx, p)
				//if err != nil {
				//	return err
				//}
				dataTwo.Type = "2"
				dataOne = append(dataOne, dataTwo)
			}
		} else if info.IsDir() {
			// 子文件夹
			dir, n := filepath.Split(p)
			dir = strings.TrimSuffix(dir, "/")
			var dataTwo = new(DocumentListPublicRes)
			dataTwo.IdStr = SHA256(p)
			dataTwo.Pid = SHA256(dir)
			dataTwo.Name = n
			dataTwo.FilenPath = p
			dataTwo.Type = "2"
			dataOne = append(dataOne, dataTwo)
		} else {
			dir, n := filepath.Split(p)
			dir = strings.TrimSuffix(dir, "/")
			var dataTwo = new(DocumentListPublicRes)
			dataTwo.Pid = SHA256(dir)
			lastDotIndex := strings.LastIndex(n, ".")
			if lastDotIndex == -1 || lastDotIndex == 0 {
				dataTwo.Name = strings.Split(n, ".")[0]
			} else {
				dataTwo.Name = n[:lastDotIndex]
			}
			dataTwo.Suffix = n[lastDotIndex:]
			dataTwo.FilenPath = p
			dataTwo.Type = "1"
			//文件只能是这三种类型，其他类型进不来
			s := n[lastDotIndex:]
			if num == "1" { //资料有格式限制
				if strings.EqualFold(s, ".xls") || strings.EqualFold(s, ".xlsx") || strings.EqualFold(s, ".docx") || strings.EqualFold(s, ".doc") || strings.EqualFold(s, ".pptx") || strings.EqualFold(s, ".ppt") {
					dataOne = append(dataOne, dataTwo)
				}
			} else {
				dataOne = append(dataOne, dataTwo)
			}
		}
		return err
	})

	if err != nil {
		//fmt.Println("遍历文件夹时发生错误：", err)
		return nil, err
	}
	// 有项目id表示资料 无表模板
	if projectId > 0 {
		for i := range dataOne {
			dataOne[i].ProjectId = projectId
		}
	}
	return
}

func SHA256(str string) (hx string) {
	// 创建 SHA-256 哈希对象
	hash := sha256.New()
	// 将字符串转换为字节数组并进行哈希计算
	hash.Write([]byte(str))
	// 计算 SHA-256 哈希值
	hashedBytes := hash.Sum(nil)
	// 将哈希值转换为十六进制字符串
	hashStr := hex.EncodeToString(hashedBytes)
	return hashStr
}

// CopyFile 文件复制
func CopyFile(src, dst string) error {
	// 打开源文件
	inputFile, err := os.Open(src)
	if err != nil {
		return err
	}
	defer inputFile.Close()

	// 创建目标文件
	outputFile, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer outputFile.Close()

	// 通过 Copy 函数实现拷贝功能
	_, err = io.Copy(outputFile, inputFile)
	if err != nil {
		return err
	}

	// 确保文件内容被刷新到磁盘上
	err = outputFile.Sync()
	if err != nil {
		return err
	}

	return nil
}

// CopyDirectory 文件夹复制
func CopyDirectory(src string, dest string) error {
	// 检查源文件夹是否存在
	_, err := os.Stat(src)
	if err != nil {
		return err
	}
	// 检查目标文件夹是否存在，不存在则创建
	err = os.MkdirAll(dest, 0755)
	if err != nil {
		return err
	}

	// 遍历源文件夹
	files, err := os.ReadDir(src)
	if err != nil {
		return err
	}
	for _, file := range files {
		srcPath := src + "/" + file.Name()
		destPath := dest + "/" + file.Name()

		// 判断文件类型
		if file.IsDir() {
			// 如果是文件夹，则递归调用 copyDirectory 函数复制文件夹及其子文件
			err = CopyDirectory(srcPath, destPath)
			if err != nil {
				return err
			}
		} else {
			// 如果是文件，则复制文件到目标文件夹
			inputFile, err := os.Open(srcPath)
			if err != nil {
				return err
			}
			defer inputFile.Close()

			outputFile, err := os.Create(destPath)
			if err != nil {
				return err
			}
			defer outputFile.Close()

			_, err = io.Copy(outputFile, inputFile)
			if err != nil {
				return err
			}
		}
	}
	return nil
}

// MoveFile 文件移动
func MoveFile(source, destination string) (err error) {
	// 执行移动操作
	err = os.Rename(source, destination)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("File moved successfully!")
	}
	return err
}

// MoveFolder 文件夹下面的文件及子文件全部移动到新文件夹下
func MoveFolder(srcPath, destPath string) error {
	// 获取源文件夹下的所有文件和子文件夹
	fileList := []string{}
	err := filepath.Walk(srcPath, func(path string, info os.FileInfo, err error) error {
		fileList = append(fileList, path)
		return nil
	})
	if err != nil {
		return err
	}

	// 移动每个文件和子文件夹
	for _, file := range fileList {
		// 获取相对路径
		relPath, err := filepath.Rel(srcPath, file)
		if err != nil {
			return err
		}

		// 构建目标路径
		destFile := filepath.Join(destPath, relPath)
		// 判断是文件还是文件夹
		if fileInfo, err := os.Stat(file); err == nil && fileInfo.IsDir() {
			// 如果是文件夹，创建目标文件夹
			err := os.MkdirAll(destFile, os.ModePerm)
			if err != nil {
				return err
			}
		} else {
			// 如果是文件，复制文件
			err := copyFile(file, destFile)
			if err != nil {
				return err
			}
		}
	}

	// 移动完成后删除源文件夹
	return os.RemoveAll(srcPath)
}

func copyFile(src, dest string) error {
	srcFile, err := os.Open(src)
	if err != nil {
		return err
	}
	defer srcFile.Close()

	destFile, err := os.Create(dest)
	if err != nil {
		return err
	}
	defer destFile.Close()

	_, err = io.Copy(destFile, srcFile)
	return err
}

// FolderToZip 将给定文件夹压缩成压缩包存储到另外一个路径（参数：源数据、目标路径）
func FolderToZip(folderToZip, zipFile string) (err error) {
	// 创建一个新的压缩包文件
	newZipFile, err := os.Create(zipFile)
	if err != nil {
		return err
	}
	defer newZipFile.Close()
	// 创建一个 zip.Writer 来向压缩包中写入内容
	zipWriter := zip.NewWriter(newZipFile)
	defer zipWriter.Close()

	// 递归遍历文件夹并将其中的文件和目录添加到压缩包中
	err = filepath.Walk(folderToZip, func(filePath string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		// 获取当前文件的相对路径
		relativePath, err := filepath.Rel(folderToZip, filePath)
		if err != nil {
			return err
		}
		// 如果是目录，则创建一个目录项
		if info.IsDir() {
			_, err = zipWriter.Create(relativePath + "/")
			if err != nil {
				return err
			}
			return nil
		}
		// 如果是文件，则创建一个文件项并写入文件内容
		fileData, err := ioutil.ReadFile(filePath)
		if err != nil {
			return err
		}
		file, err := zipWriter.Create(relativePath)
		if err != nil {
			return err
		}
		_, err = file.Write(fileData)
		if err != nil {
			return err
		}
		return nil
	})
	return
}

// zipDirFiles 压缩文件
func ZipDirFiles(src_dir string, zip_file_name string) error {
	// 检查并创建目标目录
	err := os.MkdirAll(filepath.Dir(zip_file_name), os.ModePerm)
	if err != nil {
		return err
	}

	// 删除空的zip，而不是直接使用os.RemoveAll，以提高安全性
	err = os.Remove(zip_file_name)
	if err != nil && !os.IsNotExist(err) {
		return err
	}

	// 创建新的zip文件
	zipfile, err := os.Create(zip_file_name)
	if err != nil {
		return err
	}
	defer zipfile.Close()

	// 初始化zip写入器
	archive := zip.NewWriter(zipfile)
	defer archive.Close()

	// 遍历源目录下的文件和子目录
	return filepath.Walk(src_dir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		// 计算相对于源目录的路径
		relPath, _ := filepath.Rel(src_dir, path)
		if path == src_dir {
			// 如果是源目录本身，跳过
			return nil
		}

		// 创建zip文件头
		header, err := zip.FileInfoHeader(info)
		if err != nil {
			return err
		}
		header.Name = filepath.ToSlash(relPath)

		// 标记目录
		if info.IsDir() {
			header.Name += "/"
			return nil
		}

		// 处理文件
		file, err := os.Open(path)
		if err != nil {
			return err
		}
		defer file.Close()

		writer, err := archive.CreateHeader(header)
		if err != nil {
			return err
		}

		_, err = io.Copy(writer, file)
		return err
	})

}

// 压缩后删除源文件
func DeleteFolderToZip(srcpath, destpathzip string) (err error) {
	//srcpath := filepath.ToSlash(`D:\GiteeProject\gsproject\zmkg-back\resource\public\temporary\del`)
	//destpathzip := filepath.ToSlash(`D:\GiteeProject\gsproject\zmkg-back\resource\public\temporary\yy.zip`)
	err = ZipDirFiles(srcpath, destpathzip) // 文件压缩 压缩文件目录  和压缩文件zip
	if err != nil {
		return err
	}
	// 删除原文件
	if err := os.RemoveAll(srcpath); err != nil {
		if !os.IsNotExist(err) {
			fmt.Printf("Error removing existing file %s: %v\n", srcpath, err)
			return err
		}
	}
	return err
}

// 判断字符串中是否包含斜杠
func hasSlash(s string) bool {
	for _, c := range s {
		if c == '/' || c == '\\' {
			return true
		}
	}
	return false
}