package main

import (
	"flag"
	"fmt"
	"strconv"
	"strings"
)

func paramConfig(fs *flag.FlagSet) *string {
	return fs.String("config", "cfg.toml", "Config file.")
}
func paramMap(fs *flag.FlagSet) *string {
	return fs.String("map", "", "target map setting")
}

func paramSourcePath(fs *flag.FlagSet) *string {
	return fs.String("source", "", "Source path or filename")
}

func paramDestPath(fs *flag.FlagSet) *string {
	return fs.String("dest", "", "Destination path or filename")
}

func paramAppid(fs *flag.FlagSet) *string {
	return fs.String("appid", "", "Wechat appid")
}

func paramUserids(fs *flag.FlagSet) *string {
	return fs.String("userids", "", "Device ID or Wechat UserID, separated by comma")
}

func paramBatchSize(fs *flag.FlagSet) *uint {
	return fs.Uint("batchsize", 10000, "Batch size to sync")
}

func paramBlockSize(fs *flag.FlagSet) uint64 {
	bsize := fs.String("blocksize", "50M", "Block size to make hash. using size mode K, M, G, T")
	num, err := ParseByteSize(*bsize)
	if err != nil {
		fmt.Println("Error parsing block size", "err", err)
		fmt.Println("Using default 50M")
		num = 50 * 1024 * 1024

	}
	return num
}

func paramAsync(fs *flag.FlagSet) *bool {
	return fs.Bool("async", false, "Async mode")
}

func paramClear(fs *flag.FlagSet) *bool {
	return fs.Bool("clear", false, "Clear all data before write")
}

// ParseByteSize 解析字节大小字符串为字节数
func ParseByteSize(sizeStr string) (uint64, error) {
	sizeStr = strings.TrimSpace(sizeStr)
	unit := ""
	numStr := sizeStr
	// 提取单位
	if len(sizeStr) > 1 && (sizeStr[len(sizeStr)-1] == 'B' || sizeStr[len(sizeStr)-1] == 'b') {
		unit = string(sizeStr[len(sizeStr)-2:])
		numStr = sizeStr[:len(sizeStr)-2]
	} else if len(sizeStr) > 0 && (sizeStr[len(sizeStr)-1] >= 'A' && sizeStr[len(sizeStr)-1] <= 'Z' ||
		sizeStr[len(sizeStr)-1] >= 'a' && sizeStr[len(sizeStr)-1] <= 'z') {
		unit = string(sizeStr[len(sizeStr)-1])
		numStr = sizeStr[:len(sizeStr)-1]
	}

	// 解析数字部分
	num, err := strconv.ParseFloat(numStr, 64)
	if err != nil {
		return 0, err
	}

	// 根据单位计算字节数
	switch strings.ToUpper(unit) {
	case "":
		return uint64(num), nil
	case "K", "KB":
		return uint64(num * 1024), nil
	case "M", "MB":
		return uint64(num * 1024 * 1024), nil
	case "G", "GB":
		return uint64(num * 1024 * 1024 * 1024), nil
	case "T", "TB":
		return uint64(num * 1024 * 1024 * 1024 * 1024), nil
	default:
		return 0, fmt.Errorf("unknown unit: %s", unit)
	}
}

/*
func main() {
    sizes := []string{"1K", "2M", "3G", "4T", "5"}
    for _, sizeStr := range sizes {
        size, err := ParseByteSize(sizeStr)
        if err != nil {
            fmt.Printf("Error parsing %s: %v\n", sizeStr, err)
        } else {
            fmt.Printf("%s = %d bytes\n", sizeStr, size)
        }
    }
}
*/