package utils

import (
	"bufio"
	"github.com/kataras/golog"
	"io"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"time"
)

// 根据目录获取文件或文件夹信息，不递归获取
func GetFilesByDir(prefixPath string) (fileInfos []os.FileInfo, err error) {
	var (
		fileNames []string
	)
	scanPath := filepath.Join(prefixPath, "*")
	fileNames, err = filepath.Glob(scanPath)
	if err != nil {
		return nil, err
	}
	for _, fileName := range fileNames {

		fileInfo, err := os.Stat(fileName)
		if err != nil {
			return nil, err
		}
		fileInfos = append(fileInfos, fileInfo)
	}

	return
}

func GetFilesByDirFileRegex1(prefixDir string, regex string) (fileInfos []os.FileInfo, err error) {

	var (
		fileNames []string
	)

	scanPath := filepath.Join(prefixDir, regex)
	fileNames, err = filepath.Glob(scanPath)
	if err != nil {
		return nil, err
	}
	for _, fileName := range fileNames {

		fileInfo, err := os.Stat(fileName)
		if err != nil {
			return nil, err
		}
		fileInfos = append(fileInfos, fileInfo)
	}

	return
}

func ReadContentByFileName(fileFullName string) (fileContent []string, err error) {
	var (
		file *os.File
		line string
	)

	file, err = os.Open(fileFullName)
	if err != nil {
		golog.Error(err)
		return nil, err
	}
	defer file.Close()

	rd := bufio.NewReader(file)

	for {
		line, err = rd.ReadString('\n')
		if err != nil && err != io.EOF {
			golog.Error(err)
			return nil, err
		}
		if err == io.EOF {
			break
		}
		fileContent = append(fileContent, line)
	}

	return fileContent, nil
}

// 获取指定相对路径的绝对路径
func GetCurrentPath(inDir string) string {
	dir, err := filepath.Abs(filepath.Dir(inDir)) //返回绝对路径  filepath.Dir(os.Args[0])去除最后一个元素的路径
	if err != nil {
		log.Fatal(err)
	}
	return strings.Replace(dir, "\\", "/", -1)
}

// 判断文件或者路径是否存在
func PathExists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	}
	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err
}

// 一次性读取
func ReadAll(filePth string) ([]byte, error) {
	f, err := os.Open(filePth)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	/*
	   ReadAll从r读取数据直到EOF或遇到error，返回读取的数据和遇到的错误。
	   成功的调用返回的err为nil而非EOF。
	   因为本函数定义为读取r直到EOF，它不会将读取返回的EOF视为应报告的错误。
	*/
	return ioutil.ReadAll(f)
}

// 分块读取 可在速度和内存占用之间取得很好的平衡。
func ReadBlock(filePth string, bufSize int, hookfn func([]byte)) error {
	f, err := os.Open(filePth)
	if err != nil {
		return err
	}
	defer f.Close()

	buf := make([]byte, bufSize) //一次读取多少个字节
	/*
	   NewReader创建一个具有默认大小缓冲、从r读取的*Reader。
	*/
	bfRd := bufio.NewReader(f)
	for {
		n, err := bfRd.Read(buf)
		hookfn(buf[:n]) // n 是成功读取字节数

		if err != nil { //遇到任何错误立即返回，并忽略 EOF 错误信息
			if err == io.EOF {
				return nil
			}
			return err
		}
	}

	return nil
}

// 输出到控制台
func processTask(line []byte) {
	os.Stdout.Write(line)
	//fmt.Println(string(line))
}

// 逐行读取
func ReadLine(filePth string, hookfn func([]byte)) error {
	f, err := os.Open(filePth)
	if err != nil {
		return err
	}
	defer f.Close()

	bfRd := bufio.NewReader(f)
	for {
		line, err := bfRd.ReadBytes('\n')
		hookfn(line)
		if err != nil {
			if err == io.EOF {
				return nil
			}
			return err
		}
	}
	return nil
}

// 文件监控
func FileMonitoring(filePth string, hookfn func([]byte)) {
	f, err := os.Open(filePth)
	if err != nil {
		log.Fatalln(err)
	}
	defer f.Close()

	rd := bufio.NewReader(f)
	f.Seek(0, 2)
	for {
		line, err := rd.ReadBytes('\n')
		// 如果是文件末尾不返回
		if err == io.EOF {
			time.Sleep(500 * time.Millisecond)
			continue
		} else if err != nil {
			log.Fatalln(err)
		}
		go hookfn(line)
	}

}

func ProgramName() string {
	var dirSplit string
	switch runtime.GOOS {
	case "windows":
		dirSplit = "\\"
	default:
		dirSplit = "/"
	}

	path, err := os.Executable()
	if err != nil {
		log.Printf(err.Error())
	}
	dir := filepath.Dir(path) + dirSplit
	//fmt.Println(path) // for example /home/user/main
	//fmt.Println(dir)  // for example /home/user
	programName := strings.TrimPrefix(path, dir)
	if strings.HasSuffix(programName, ".exe") {
		programName = strings.TrimSuffix(programName, ".exe")
	}
	return programName
}