package starainrt

import (
	"bufio"
	"crypto/md5"
	"crypto/rc4"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/sha512"
	"encoding/base64"
	"encoding/hex"
	"fmt"
	"hash/crc32"
	"io"
	"io/ioutil"
	"os"
	"regexp"
	"strconv"
	"strings"
)

func Exists(filepath string) bool {
	_, err := os.Stat(filepath)
	if err != nil && os.IsNotExist(err) {
		return false
	}
	return true
}
func IsFile(fpath string) bool {
	s, err := os.Stat(fpath)
	if err != nil {
		return false
	}
	return !s.IsDir()
}
func ReWriteFileByKV(filepath, rem, conn, ret string, kv map[string]string) bool {
	var outputstr string
	var ataru bool = false
	if (!Exists(filepath)) || (!IsFile(filepath)) {
		return false
	}
	fso, err := os.Open(filepath)
	if err != nil {
		return false
	}
	rempar := regexp.MustCompile("^" + rem)
	buf := bufio.NewReader(fso)
	for {
		bytxt, _, eof := buf.ReadLine()
		if eof == io.EOF {
			break
		}
		txt := strings.TrimSpace(string(bytxt))
		if rempar.Match([]byte(txt)) {
			outputstr += txt + ret
			continue
		}
		for k, v := range kv {
			keypar := regexp.MustCompile("^" + k)
			if keypar.Match([]byte(txt)) {
				ataru = true
				outputstr += k + conn + v + ret
				delete(kv, k)
			}
		}
		if ataru {
			ataru = false
			continue
		} else {
			outputstr += txt + ret
		}
	}
	fso.Close()
	if len(kv) != 0 {
		for k, v := range kv {
			outputstr += k + conn + v + ret
			delete(kv, k)
		}
	}
	err = ioutil.WriteFile(filepath, []byte(outputstr), 0755)
	if err != nil {
		return false
	}
	return true
}

func GetINIValue(filepath, rem, conn string, kv []string) (bool, map[string]string) {
	outputstr := make(map[string]string)
	if (!Exists(filepath)) || (!IsFile(filepath)) {
		return false, outputstr
	}
	fso, err := os.Open(filepath)
	if err != nil {
		return false, outputstr
	}
	rempar := regexp.MustCompile("^" + rem)
	buf := bufio.NewReader(fso)
	for {
		bytxt, _, eof := buf.ReadLine()
		if eof == io.EOF {
			break
		}
		txt := strings.TrimSpace(string(bytxt))
		if rempar.Match([]byte(txt)) {
			continue
		}
		var i int = 0
		var v2 string
		for k, v := range kv {
			if v == "" {
				continue
			}
			v2 = ""
			for _, b := range []byte(v) {
				switch string(b) {
				case ".":
					v2 += "\\."
				case "\\":
					v2 += "\\"
				case "-":
					v2 += "\\-"
				case "(":
					v2 += "\\("
				case ")":
					v2 += "\\)"
				case "{":
					v2 += "\\{"
				case "}":
					v2 += "\\}"
				case "[":
					v2 += "\\["
				case "]":
					v2 += "\\]"
				case "$":
					v2 += "\\]$"
				case "^":
					v2 += "\\^"
				default:
					v2 += string(b)
				}
			}
			keypar := regexp.MustCompile("^" + v2 + ".*?" + conn + "(.*)")
			if keypar.Match([]byte(txt)) {
				i++
				kekka := keypar.FindSubmatch([]byte(txt))
				outputstr[v] = string(kekka[1])
				kv[k] = ""
			}
		}
		if i != len(kv) {
			for _, v := range kv {
				if v != "" {
					outputstr[v] = ""
				}
			}
		}
	}
	return true, outputstr
}

func SmallEncodeFileByBase64(filepath, outputname string, buffer int) bool {
	if !Exists(filepath) {
		return false
	}
	rempar := regexp.MustCompile(`(.*)\*(.*)`)
	if !rempar.Match([]byte(outputname)) {
		return false
	}
	rest := rempar.FindSubmatch([]byte(outputname))
	par1 := string(rest[1])
	par2 := string(rest[2])
	bfile, _ := ioutil.ReadFile(filepath)
	bitlen := len(bfile)
	i := 1
	var seed int = buffer
	if bitlen > seed {
		for bitlen > seed {
			coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1) : seed*i])
			ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755)
			i++
			bitlen -= seed
		}
	}
	coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1):])
	ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755)
	return true
}

func SmallDecodeFileByBase64(inputname, outputname string, filesum int) bool {
	rempar := regexp.MustCompile(`(.*)\*(.*)`)
	if !rempar.Match([]byte(inputname)) {
		return false
	}
	rest := rempar.FindSubmatch([]byte(inputname))
	par1 := string(rest[1])
	par2 := string(rest[2])
	for i := 1; i <= filesum; i++ {
		if !Exists(par1 + strconv.Itoa(i) + par2) {
			return false
		}
	}
	i := 1
	big := filesum
	res := []byte{}
	for i <= big {
		bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2)
		coder, _ := base64.StdEncoding.DecodeString(string(bfile))
		for _, v := range coder {
			res = append(res, v)
		}
		i++
		//time.Sleep(time.Microsecond * 560)
	}
	ioutil.WriteFile(outputname, res, 0755)
	return true
}

func EncodeFileByBase64(filepath, outputname string, buffer int) bool {
	if !Exists(filepath) {
		return false
	}
	rempar := regexp.MustCompile(`(.*)\*(.*)`)
	if !rempar.Match([]byte(outputname)) {
		return false
	}
	rest := rempar.FindSubmatch([]byte(outputname))
	par1 := string(rest[1])
	par2 := string(rest[2])
	ret := SlitFile(filepath, outputname, 0, int64(buffer), int64(buffer)/10)
	if !ret {
		return false
	}
	i := 1
	for {
		if !Exists(par1 + strconv.Itoa(i) + par2) {
			break
		} else {
			bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2)
			coder := base64.StdEncoding.EncodeToString(bfile)
			ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755)

		}
		i++
	}
	return true
}

func DecodeFileByBase64(inputname, outputname string, filesum int) bool {
	rempar := regexp.MustCompile(`(.*)\*(.*)`)
	if !rempar.Match([]byte(inputname)) {
		return false
	}
	rest := rempar.FindSubmatch([]byte(inputname))
	par1 := string(rest[1])
	par2 := string(rest[2])
	if filesum != 0 {
		for i := 1; i <= filesum; i++ {
			if !Exists(par1 + strconv.Itoa(i) + par2) {
				return false
			}
		}
	} else {
		var i int
		for i = 1; ; i++ {
			if !Exists(par1 + strconv.Itoa(i) + par2) {
				break
			}
		}
		filesum = i - 1
	}
	i := 1
	big := filesum
	fpw, _ := os.Create(outputname)
	defer fpw.Close()
	for i <= big {
		bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2)
		coder, _ := base64.StdEncoding.DecodeString(string(bfile))
		fpw.Write(coder)
		i++
		//time.Sleep(time.Microsecond * 560)
	}
	return true
}

func SlitFile(filename, outputname string, num int, databig, buffer int64) bool {
	rempar := regexp.MustCompile(`(.*)\*(.*)`)
	if !rempar.Match([]byte(outputname)) {
		return false
	}
	rest := rempar.FindSubmatch([]byte(outputname))
	par1 := string(rest[1])
	par2 := string(rest[2])
	if !Exists(filename) {
		return false
	}
	fileinfo, _ := os.Stat(filename)
	filesize := fileinfo.Size()
	var spbyte int64
	if num != 0 {
		spbyte = filesize / int64(num)
	}
	if databig != 0 {
		spbyte = databig
		num = int(filesize/spbyte + 1)
	}
	if buffer == 0 {
		buffer = spbyte / 10
	}
	if buffer > 100*1024*1024 {
		buffer = 50 * 1024 * 1024
	}
	fp, _ := os.Open(filename)
	defer fp.Close()
	data := make([]byte, buffer)
	var i int64 = 0
	var k int = 1
	fpw, _ := os.Create(par1 + strconv.Itoa(k) + par2)
	for {
		data = data[:cap(data)]

		// read bytes to slice
		n, err := fp.Read(data)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
			break
		}
		i += int64(n)
		data = data[:n]
		fpw.Write(data)
		if i > spbyte && k < num {
			fpw.Close()
			k++
			i = 1
			fpw, _ = os.Create(par1 + strconv.Itoa(k) + par2)
			defer fpw.Close()
		}
	}
	return true
}

func SpliceFile(inputname, outputname string, num int, buffer int64) bool {
	rempar := regexp.MustCompile(`(.*)\*(.*)`)
	if !rempar.Match([]byte(inputname)) {
		return false
	}
	rest := rempar.FindSubmatch([]byte(inputname))
	par1 := string(rest[1])
	par2 := string(rest[2])
	if num != 0 {
		for i := 1; i <= num; i++ {
			if !Exists(par1 + strconv.Itoa(i) + par2) {
				return false
			}
		}
	} else {
		var i int
		for i = 1; ; i++ {
			if !Exists(par1 + strconv.Itoa(i) + par2) {
				break
			}
		}
		num = i - 1
	}
	fpw, _ := os.Create(outputname)
	defer fpw.Close()
	fileinfo, _ := os.Stat(par1 + "1" + par2)
	filesize := fileinfo.Size()
	if buffer == 0 {
		buffer = filesize / 5
	}
	if buffer > 1024*1024*100 {
		buffer = 1024 * 1024 * 100
	}
	data := make([]byte, buffer)
	for i := 1; i <= num; i++ {
		fp, _ := os.Open(par1 + strconv.Itoa(i) + par2)
		for {
			data = data[:cap(data)]
			// read bytes to slice
			n, err := fp.Read(data)
			if err != nil {
				if err == io.EOF {
					break
				}
				fmt.Println(err)
				break
			}
			data = data[:n]
			fpw.Write(data)
		}
		fp.Close()
	}
	return true
}

func MixFile(filepath, outputname string, buffer int64, remix bool) bool {
	if !Exists(filepath) || !IsFile(filepath) {
		return false
	}
	fileinfo, _ := os.Stat(filepath)
	filesize := fileinfo.Size()
	if buffer == 0 {
		buffer = filesize / 5
	}
	if buffer > 1024*1024*100 {
		buffer = 1024 * 1024 * 100
	}
	var spbyte int64
	if !remix {
		spbyte = filesize / 2
	} else {
		spbyte = filesize - filesize/2
	}
	fpw, _ := os.Create(outputname)
	defer fpw.Close()
	fp, _ := os.Open(filepath)
	defer fp.Close()
	data := make([]byte, buffer)
	_, _ = fp.Seek(spbyte, 0)
	for {
		data = data[:cap(data)]

		// read bytes to slice
		n, err := fp.Read(data)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
			break
		}
		data = data[:n]
		fpw.Write(data)
	}
	_, _ = fp.Seek(0, 0)
	i := int64(0)
	for {
		data = data[:cap(data)]

		// read bytes to slice
		n, err := fp.Read(data)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
			break
		}
		i += int64(n)
		if i < spbyte {
			data = data[:n]
			fpw.Write(data)
		} else {
			data = data[:(int64(n) - i + spbyte)]
			fpw.Write(data)
			break
		}
	}
	return true
}

func Md5File(filepath string) string {
	f, err := os.Open(filepath)
	if err != nil {
		fmt.Println("Open", err)
		return ""
	}
	defer f.Close()
	md5hash := md5.New()
	if _, err := io.Copy(md5hash, f); err != nil {
		fmt.Println("Copy", err)
		return ""
	}
	result := md5hash.Sum(nil)
	return hex.EncodeToString(result)
}

func Crc32File(filepath string) string {
	f, err := os.Open(filepath)
	if err != nil {
		fmt.Println("Open", err)
		return ""
	}

	defer f.Close()
	crchash := crc32.NewIEEE()
	if _, err := io.Copy(crchash, f); err != nil {
		fmt.Println("Copy", err)
		return ""
	}
	result := crchash.Sum(nil)
	return hex.EncodeToString(result)
}

func Sha1File(filepath string) string {
	f, err := os.Open(filepath)
	if err != nil {
		fmt.Println("Open", err)
		return ""
	}

	defer f.Close()
	sha1hash := sha1.New()
	if _, err := io.Copy(sha1hash, f); err != nil {
		fmt.Println("Copy", err)
		return ""
	}
	result := sha1hash.Sum(nil)
	return hex.EncodeToString(result)
}

func Sha256File(filepath string) string {
	f, err := os.Open(filepath)
	if err != nil {
		fmt.Println("Open", err)
		return ""
	}

	defer f.Close()
	sha256hash := sha256.New()
	if _, err := io.Copy(sha256hash, f); err != nil {
		fmt.Println("Copy", err)
		return ""
	}
	result := sha256hash.Sum(nil)
	return hex.EncodeToString(result)
}

func Sha512File(filepath string) string {
	f, err := os.Open(filepath)
	if err != nil {
		fmt.Println("Open", err)
		return ""
	}

	defer f.Close()
	sha512hash := sha512.New()
	if _, err := io.Copy(sha512hash, f); err != nil {
		fmt.Println("Copy", err)
		return ""
	}
	result := sha512hash.Sum(nil)
	return hex.EncodeToString(result)
}

func RC4File(filepath string, key []byte) string {
	rc4obj, _ := rc4.NewCipher(key)
	plain, _ := ioutil.ReadFile(filepath)
	res := make([]byte, len(plain))
	rc4obj.XORKeyStream(res, plain)
	return hex.EncodeToString(res)
}
func DetachFile(source, output1, output2 string, key int64) bool {
	if !Exists(source) {
		return false
	}
	fin, _ := os.Stat(source)
	filesize := fin.Size()
	fpw, _ := os.Create(output1)
	fp, _ := os.Open(source)
	defer fp.Close()
	buffer := filesize / 10
	if buffer > 100*1024*1024 {
		buffer = 100 * 1024 * 1024
	}
	data := make([]byte, buffer)
	i := int64(0)
	for {
		data = data[:cap(data)]

		// read bytes to slice
		n, err := fp.Read(data)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
			break
		}
		i += int64(n)
		if i < key {
			data = data[:n]
			fpw.Write(data)
		} else {
			data = data[:(int64(n) - i + key)]
			fpw.Write(data)
			break
		}
	}
	fpw.Close()
	_, _ = fp.Seek(key+20, 0)
	fpw, _ = os.Create(output2)
	for {
		data = data[:cap(data)]

		// read bytes to slice
		n, err := fp.Read(data)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
			break
		}
		data = data[:n]
		fpw.Write(data)
	}
	return true
}
func AttachFile(source, target, output string) (bool, string) {
	if !Exists(source) {
		return false, ""
	}
	if !Exists(target) {
		return false, ""
	}
	fin, _ := os.Stat(source)
	filesize := fin.Size()
	_ = ioutil.WriteFile(output+".ini", []byte(strconv.FormatInt(filesize, 10)), 0755)
	fpw, _ := os.Create(output)
	defer fpw.Close()
	fp, _ := os.Open(source)
	buffer := filesize / 10
	if buffer > 100*1024*1024 {
		buffer = 100 * 1024 * 1024
	}
	data := make([]byte, buffer)
	for {
		data = data[:cap(data)]
		// read bytes to slice
		n, err := fp.Read(data)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
			break
		}
		data = data[:n]
		fpw.Write(data)
	}
	fp.Close()
	fpw.Write([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
	fin, _ = os.Stat(target)
	filesize2 := fin.Size()
	fp, _ = os.Open(target)
	buffer = filesize2 / 10
	if buffer > 100*1024*1024 {
		buffer = 100 * 1024 * 1024
	}
	data = make([]byte, buffer)
	for {
		data = data[:cap(data)]
		// read bytes to slice
		n, err := fp.Read(data)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println(err)
			break
		}
		data = data[:n]
		fpw.Write(data)
	}
	fp.Close()
	return true, strconv.FormatInt(filesize, 10)
}