package main

import (

    "encoding/base64"

    "fmt"

    "os"

    "net/http"

    "io/ioutil"

    "strings"

    "path/filepath"

    "encoding/json"

    "errors"

    "bytes"

    "time"

    "sync"

    "strconv"

    "bufio"

    "io"

)

var sum_file_count int =

var handle_file_count int =

var wg sync.WaitGroup

var invalid_keys map[string]int

var keys_user_count map[string]int

func main() {

    url := "https://api.tinify.com/shrink"

    if len(os.Args) <  {

        fmt.Println("==该工具用于使用 TinyPng 服务进行图片压缩处理，需要传一个文件夹参数，程序会自动递归搜索其中的 *.png 文件进行处理，处理完毕后会覆盖原文件==\n")

        return

    }

    dirPath := os.Args[]

    keys := []string{}

    key_file, err := os.Open("keys.txt")

    defer key_file.Close()

    if err != nil {

        error_msg := fmt.Sprintf("读取 KEY 文件错误，文件路径错误! (path: %s\terror: %s)", "keys.txt", err.Error())

        fmt.Printf(error_msg)

        return

    }

    rd := bufio.NewReader(key_file)

    for {

        line, err := rd.ReadString('\n')

        if err != nil || err == io.EOF {

            break

        }

        if len(line) >  {

            keys = append(keys,strings.Trim(line,"\n"))

        }

    }

    /*

    for _,v := range keys{

        println(v)

    }

    */

    files, err := WalkDir(dirPath, ".png")

    if err != nil {

        fmt.Println("请检查目录是否存在~~")

        return

    }

    sum_file_count = len(files)

    if sum_file_count ==  {

        fmt.Println("没有 *.png 图片需要处理~~")

        return

    }

    fmt.Printf("有 %d 张图片需要处理，请稍候~~\n",sum_file_count)

    invalid_keys = make(map[string]int)

    keys_user_count = make(map[string]int)

    startTime := time.Now()

    for i:=;i<sum_file_count;i++ {

        wg.Add()

        shrink(url,keys,files[i])

    }

    wg.Wait()

    fmt.Printf("任务总耗时： %s\n",time.Since(startTime))

    if len(keys_user_count) >  {

        fmt.Printf("\n==KEY的本月已使用次数如下：\n")

        for k,v := range keys_user_count {

            fmt.Printf("KEY: %s\tUseCount: %d\n",k,v)

        }

    }

}

//上传图片，阻塞等待服务器压缩，服务器压缩成功返回结果后，去下载图片覆盖原图片

func shrink(url string, keys []string, filePath string) error {

    defer wg.Done()

    file_bytes, err := ioutil.ReadFile(filePath)

    if err != nil {

        error_msg := fmt.Sprintf("读取本地文件错误，文件路径错误! (path: %s\terror: %s)", filePath, err.Error())

        fmt.Println(error_msg)

        return err

    }

    down_url := ""

    for i:=;i<len(keys);i++ {if _,ok := invalid_keys[keys[i]];ok {

            continue

        }

        req, err := http.NewRequest("POST", url, bytes.NewReader(file_bytes))

        if err != nil {

            error_msg := fmt.Sprintf("请求 Tiny 出现网络错误! (error: %s)\n",err.Error())

            fmt.Println(error_msg)

            return errors.New(error_msg)

        }

        credentials := base64.StdEncoding.EncodeToString([]byte("api:" + keys[i]))

        req.Header.Set("Authorization", "Basic "+credentials)

        //处理返回结果

        res, err := http.DefaultClient.Do(req)

        if err != nil {

            error_msg := fmt.Sprintf("请求 Tiny 出现网络错误! (error: %s)\n",err.Error())

            fmt.Println(error_msg)

            return errors.New(error_msg)

        }

        status := res.StatusCode

        body, err := ioutil.ReadAll(res.Body)

        if err != nil {

            error_msg := fmt.Sprintf("请求 Tiny 出现网络错误! (error: %s)\n",err.Error())

            fmt.Println(error_msg)

            return errors.New(error_msg)

        }

        //判断HTTP状态码，如果是 415表示文件类型不正确；401表示证书不正确；400表示输入文件为空；5xx表示服务器异常；2xx表示成功

        if status ==  || status ==  {

            //KEY不正确，使用下一个KEY

            /*

            if status == 400 {

                fmt.Printf("该 KEY: %s 很可能是格式非法，请留意。\n",keys[i])

            }

            */

            invalid_keys[keys[i]] =

            time.Sleep(time.Millisecond * )

            continue

        } else if status <  && status >=  {

            //正确

            right_data := new(RightData)

            json.Unmarshal(body, right_data)

            down_url = right_data.Output.Url

            CompressionCount := res.Header.Get("Compression-Count")

            CompressionCountInt, err := strconv.Atoi(CompressionCount)

            if err != nil {

                CompressionCountInt =

            }

            if CompressionCountInt > keys_user_count[keys[i]] {

                keys_user_count[keys[i]] = CompressionCountInt

            }

            break

        } else {

            //其它错误

            error_msg := fmt.Sprintf("Tiny状态码: %d\tTiny错误信息: %s\n",res.StatusCode,string(body))

            fmt.Println(error_msg)

            return errors.New(error_msg)

        }

    }

    if down_url == "" {

        error_msg := "可能所有 KEY 都已经不可用。"

        fmt.Println(error_msg)

        return errors.New(error_msg)

    }

    //CompressionCount := res.Header.Get("Compression-Count")

    //fmt.Printf("Key(%s) UseCount: %s\n",key,CompressionCount)

    //覆盖原文件

    down_bytes := []byte{}

    for i:= ;i < ;i++ {

        if i> {

            fmt.Printf("下载图片 %s 出错，正在进行第 %d 次尝试...\n",down_url,i+)

            time.Sleep(time.Millisecond*)

        }

        res_down, err := http.Get(down_url)

        if err != nil {

            continue

        }

        down_bytes, err = ioutil.ReadAll(res_down.Body)

        if err != nil {

            continue

        }

        break

    }

    if len(down_bytes) ==  {

        error_msg := fmt.Sprintf("下载图片出错!(filePath: %s\turl: %s\terror: %s)\n", filePath,down_url,err.Error())

        fmt.Printf(error_msg)

        return errors.New(error_msg)

    }

    file, err := os.OpenFile(filePath,os.O_RDWR | os.O_TRUNC, )

    defer file.Close()

    if err != nil {

        error_msg := fmt.Sprintf("清空原图片出错!(filePath: %s\turl: %s\terror: %s)\n", filePath,down_url,err.Error())

        fmt.Printf(error_msg)

        return errors.New(error_msg)

    }

    _, err = file.Write(down_bytes)

    if err != nil {

        error_msg := fmt.Sprintf("覆写原图片出错!(filePath: %s\turl: %s\terror: %s)\n", filePath,down_url,err.Error())

        fmt.Printf(error_msg)

        return errors.New(error_msg)

    }

    handle_file_count +=

    fmt.Printf("任务进度[%d/%d]\n",handle_file_count,sum_file_count)

    return nil

}

//获取指定目录下的所有文件，不进入下一级目录搜索，可以匹配后缀过滤。

func ListDir(dirPth string, suffix string) (files []string, err error) {

    files = make([]string, , )

    dir, err := ioutil.ReadDir(dirPth)

    if err != nil {

        return nil, err

    }

    PthSep := string(os.PathSeparator)

    suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写

    for _, fi := range dir {

        if fi.IsDir() { // 忽略目录

            continue

        }

        if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) { //匹配文件

            files = append(files, dirPth+PthSep+fi.Name())

        }

    }

    return files, nil

}

//获取指定目录及所有子目录下的所有文件，可以匹配后缀过滤。

func WalkDir(dirPth, suffix string) (files []string, err error) {

    files = make([]string, , )

    suffix = strings.ToUpper(suffix) //忽略后缀匹配的大小写

    err = filepath.Walk(dirPth, func(filename string, fi os.FileInfo, err error) error { //遍历目录

        //if err != nil { //忽略错误

        // return err

        //}

        if fi.IsDir() { // 忽略目录

            return nil

        }

        if strings.HasSuffix(strings.ToUpper(fi.Name()), suffix) {

            files = append(files, filename)

        }

        return nil

    })

    return files, err

}

type RightData struct {

    Input struct {

        Size int     `json:"size"`

        Type string     `json:"type"`

    } `json:"input"`

    Output struct {

        Size int    `json:"size"`

        Type string    `json:"type"`

        Width int    `json:"width"`

        Height int    `json:"height"`

        Ratio float32    `json:"ratio"`

        Url string    `json:"url"`

    }

}