package util

import (
	"archive/zip"
	"encoding/base64"
	"fmt"
	"io"
	"os"
	"path"
	"path/filepath"
	"strings"
	"xtcfs/config"
)

/**
** dirPath 目标目录
** relativeOnly:是否为相对目录
**/
// 遍历目录下的文件
func GetDirFilePaths(dirPath string, relativeOnly bool) ([]string, error) {
	var filePaths []string
	err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			if relativeOnly {
				fileName := filepath.Base(path)
				relativePath := filepath.ToSlash(filepath.Join(filepath.Base(dirPath), fileName))
				filePaths = append(filePaths, relativePath)
			} else {
				filePaths = append(filePaths, filepath.ToSlash(path))
			}
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return filePaths, nil
}

// dest：目的地址以及压缩文件名   eg:/data/logZip/2022-12-12-log.zip
// paths：需要压缩的所有文件所组成的集合
func CompressToZip(dest string, currentPath string, paths []string) error {
	// fmt.Println("real path", currentPath)
	// 打开files 目录
	filesPath := ""
	if dir, err := os.Getwd(); err == nil {
		filesPath = dir + "/files/"
	}
	if err := os.MkdirAll(filesPath, 0755); err != nil {
		fmt.Println(err.Error())
	}
	// ToSlash 过滤windows的斜杠引起的bug
	zfile, err := os.Create(path.Join("./files", "/", dest))
	if err != nil {
		return err
	}
	defer zfile.Close()
	zipWriter := zip.NewWriter(zfile)
	defer zipWriter.Close()

	// 遍历带压缩的目录信息
	for _, src := range paths {
		// 替换文件名，并且去除前后 "\" 或 "/"
		// path = strings.Trim(path, string(filepath.Separator))
		// 从配置中读取到源目录
		src = path.Join(currentPath, "/", src)
		// 删除尾随路径（如果它是目录）
		src := strings.TrimSuffix(src, string(os.PathSeparator))
		err = filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}
			// 创建本地文件头
			header, err := zip.FileInfoHeader(info)
			if err != nil {
				return err
			}
			// 将压缩方法设置为deflate
			header.Method = zip.Deflate

			// 在zip存档中设置文件的相对路径
			header.Name, err = filepath.Rel(filepath.Dir(src), path)
			if err != nil {
				return err
			}

			// 目录需要拼上一个 "/" ，否则会出现一个和目录一样的文件在压缩包中
			if info.IsDir() {
				// header.Name += string(os.PathSeparator)
				header.Name += "/"
			} else {
				// 替换一下分隔符，zip不支持 "\\"
				header.Name = strings.ReplaceAll(header.Name, "\\", "/")
			}
			// 创建写入头的writer
			headerWriter, err := zipWriter.CreateHeader(header)
			if err != nil {
				return err
			}
			if info.IsDir() {
				return nil
			}
			f, err := os.Open(path)
			if err != nil {
				return err
			}
			defer f.Close()
			_, err = io.Copy(headerWriter, f)
			return err
		})
		if err != nil {
			return err
		}
	}
	// 存到指定位置
	os.Rename(dest, path.Join("./files/", dest))
	return nil
}

// 解压缩zip文件
// 这个方法必须是首字母大写的，才能被注册
// src: 需要解压的zip文件
func DecompressZip(zpFname string) error {
	// 下载文件
	archive, err := zip.OpenReader(zpFname)
	if err != nil {
		return err
	}
	dir := filepath.Dir(zpFname)
	fmt.Printf("zip file path:%s\n", dir)

	defer archive.Close()
	// 遍历目录
	for _, f := range archive.File {
		// zip 解压的时候，路径为监听的路径
		filePath := filepath.Join(config.G.FilePath, f.Name)
		//filePath := filepath.Join(dir, f.Name)
		if f.FileInfo().IsDir() {
			os.MkdirAll(filePath, os.ModePerm)
			continue
		}
		// 父文件夹开始闯将目录
		if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
			return fmt.Errorf("failed to make directory (%v)", err)
		}
		// 文件原有模式
		dstFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
		if err != nil {
			return fmt.Errorf("failed to create file (%v)", err)
		}
		fileInArchive, err := f.Open()
		if err != nil {
			return fmt.Errorf("failed to open file in zip (%v)", err)
		}
		if _, err := io.Copy(dstFile, fileInArchive); err != nil {
			return fmt.Errorf("failed to copy file in zip (%v)", err)
		}
		dstFile.Close()
		fileInArchive.Close()
	}
	return nil
}

// base64 encode
// url safe
func Bas64end(str string) string {
	// bdata:=
	return base64.URLEncoding.EncodeToString([]byte(str))
}

// base64 url safe uneconde
func Base64dec(bsstr string) string {
	dedc, _ := base64.URLEncoding.DecodeString(bsstr)
	return string(dedc)
}

// 文件备份
func Filebackup(src, dst string) error {
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()

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

	_, err = io.Copy(out, in)
	if err != nil {
		return err
	}

	return out.Sync()
}

// 判断文件是否存在
func IsFileExist(filename string) bool {
	if _, err := os.Stat(filename); err == nil {
		return true
	}
	return false
}

// package main

// import (
//     "archive/zip"
//     "fmt"
//     "io"
//     "os"
// )

// 解压zip文件到指定目录，不覆盖已存在的文件
// func UnzipWithoutOverwrite(zipFile, destDir string) error {
// 	reader, err := zip.OpenReader(zipFile)
// 	if err != nil {
// 		return err
// 	}
// 	defer reader.Close()

// 	for _, file := range reader.Reader.File {
// 		path := destDir + "/" + file.Name
// 		if file.FileInfo().IsDir() {
// 			err = os.MkdirAll(path, file.Mode())
// 			if err != nil {
// 				return err
// 			}
// 			continue
// 		}

// 		if _, err := os.Stat(path); err == nil {
// 			// 文件已存在，跳过
// 			continue
// 		}

// 		rc, err := file.Open()
// 		if err != nil {
// 			return err
// 		}
// 		defer rc.Close()

// 		err = os.MkdirAll(getDir(path), os.ModePerm)
// 		if err != nil {
// 			return err
// 		}

// 		w, err := os.Create(path)
// 		if err != nil {
// 			return err
// 		}
// 		defer w.Close()

// 		_, err = io.Copy(w, rc)
// 		if err != nil {
// 			return err
// 		}
// 		w.Chmod(file.Mode())
// 	}
// 	return nil
// }

// // 获取目录部分
// func getDir(path string) string {
// 	return path[:len(path)-len(os.PathSeparator)+1]
// }

// func main() {
//     zipFile := "example.zip"
//     destDir := "output"
//     err := UnzipWithoutOverwrite(zipFile, destDir)
//     if err != nil {
//         fmt.Println(err)
//     }
// }