// main.go
package main

import (
    "bytes"
    "crypto/rand"
    "encoding/hex"
    "encoding/json"
    "flag"
    "fmt"
    "io"
    "log"
    "net"
    "net/http"
    "os/exec"
    "runtime"
    "time"
)

const apiBaseURL = "https://appapi.rtstudio.top"

var loginType string
var value string

type verifyResponse struct {
    Success bool   `json:"success"`
    Data    any    `json:"data"`
    Message string `json:"message"`
}

func main() {
    flag.StringVar(&loginType, "type", "", "登录类型: token 或 name")
    flag.StringVar(&value, "v", "", "软件token或软件名称")
    flag.Parse()

    if loginType != "token" && loginType != "name" {
        log.Fatal("-type 必须是 'token' 或 'name'")
    }
    if value == "" {
        log.Fatal("-v 参数不能为空")
    }

    token, err := startLoginFlow(loginType, value)
    if err != nil {
        log.Fatalf("登录失败: %v", err)
    }

    userResult, err := getUserByToken(token)
    if err != nil {
        log.Fatalf("获取用户信息失败: %v", err)
    }
    
    if userResult.Success {
        log.Printf("登录成功，用户: %+v", userResult.Data)
    }
}

// startLoginFlow 启动登录流程
func startLoginFlow(loginType, value string) (string, error) {
    state, err := generateState()
    if err != nil {
        return "", fmt.Errorf("生成state失败: %v", err)
    }

    port, err := findAvailablePort()
    if err != nil {
        return "", fmt.Errorf("无法找到可用端口: %v", err)
    }

    tokenChan := make(chan string, 1)
    errChan := make(chan error, 1)

    server := &http.Server{
        Addr:         fmt.Sprintf(":%d", port),
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        query := r.URL.Query()
        callbackType := query.Get("type")
        callbackValue := query.Get("v")
        callbackState := query.Get("state")

        if callbackType == "success" {
            if callbackState != state {
                errChan <- fmt.Errorf("state验证失败")
                http.Error(w, "state验证失败", http.StatusBadRequest)
                return
            }
            tokenChan <- callbackValue
            w.Write([]byte(`
✅ 登录完成
请关闭此窗口
`))
            go func() {
                time.Sleep(500 * time.Millisecond)
                server.Close()
            }()
        } else if callbackType == "error" {
            errChan <- fmt.Errorf("登录失败: %s", callbackValue)
            go server.Close()
        }
    })

    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            errChan <- fmt.Errorf("HTTP服务器错误: %v", err)
        }
    }()

    time.Sleep(100 * time.Millisecond)

    loginURL := fmt.Sprintf("https://apilogin.rtstudio.top/?port=%d&type=%s&v=%s&state=%s&env=app",
        port, loginType, value, state)
    
    if err := openBrowser(loginURL); err != nil {
        return "", fmt.Errorf("打开浏览器失败: %v", err)
    }

    select {
    case token := <-tokenChan:
        return token, nil
    case err := <-errChan:
        return "", err
    case <-time.After(5 * time.Minute):
        server.Close()
        return "", fmt.Errorf("登录超时")
    }
}

func generateState() (string, error) {
    b := make([]byte, 16)
    if _, err := rand.Read(b); err != nil {
        return "", err
    }
    return hex.EncodeToString(b), nil
}

func findAvailablePort() (int, error) {
    listener, err := net.Listen("tcp", ":0")
    if err != nil {
        return 0, err
    }
    defer listener.Close()
    return listener.Addr().(*net.TCPAddr).Port, nil
}

func openBrowser(url string) error {
    switch runtime.GOOS {
    case "windows":
        return exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
    case "darwin":
        return exec.Command("open", url).Start()
    default:
        return exec.Command("xdg-open", url).Start()
    }
}

func getUserByToken(token string) (*verifyResponse, error) {
    reqBody := map[string]string{"token": token}
    jsonBody, _ := json.Marshal(reqBody)

    resp, err := http.Post(apiBaseURL+"/get-user-by-token", "application/json", bytes.NewBuffer(jsonBody))
    if err != nil {
        return nil, fmt.Errorf("API请求失败: %v", err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result verifyResponse
    json.Unmarshal(body, &result)
    return &result, nil
}