package main

import (
	"bufio"
	"bytes"
	"crypto/hmac"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

var ENCRYPTION_KEY = []byte("@sk=Rigel5729%2-diordnA")

var MODEL_REGISTRY = []Model{
	{ID: "xiaomi/mimo-v2.5", Name: "MiMo V2.5", Provider: "Xiaomi", Premium: false},
	{ID: "xiaomi/mimo-v2-flash", Name: "MiMo V2 Flash", Provider: "Xiaomi", Premium: false},
	{ID: "xiaomi/mimo-v2.5-pro", Name: "MiMo V2.5 Pro", Provider: "Xiaomi", Premium: true},
	{ID: "deepseek/deepseek-v4-flash", Name: "DeepSeek v4 Flash", Provider: "DeepSeek", Premium: false},
	{ID: "deepseek/deepseek-v4-pro", Name: "DeepSeek v4 Pro", Provider: "DeepSeek", Premium: true},
	{ID: "deepseek/deepseek-v3.2", Name: "DeepSeek v3.2", Provider: "DeepSeek", Premium: true},
	{ID: "deepseek/deepseek-v3.2-speciale", Name: "DeepSeek v3.2 Speciale", Provider: "DeepSeek", Premium: true},
	{ID: "deepseek/deepseek-v3.2-exp", Name: "DeepSeek v3.2 Exp", Provider: "DeepSeek", Premium: true},
	{ID: "deepseek/deepseek-v3.1-terminus", Name: "DeepSeek v3.1 Terminus", Provider: "DeepSeek", Premium: true},
	{ID: "deepseek/deepseek-chat-v3.1", Name: "DeepSeek v3.1 Chat", Provider: "DeepSeek", Premium: true},
	{ID: "google/gemini-2.5-flash-lite", Name: "Gemini 2.5 Flash Lite", Provider: "Google", Premium: false},
	{ID: "google/gemini-3.1-flash-lite-preview", Name: "Gemini 3.1 Flash Lite", Provider: "Google", Premium: true},
	{ID: "google/gemma-4-26b-a4b-it", Name: "Gemma 4 26B", Provider: "Google", Premium: false},
	{ID: "google/gemma-4-31b-it", Name: "Gemma 4 31B", Provider: "Google", Premium: false},
	{ID: "google/gemma-3-27b-it", Name: "Gemma 3 27B", Provider: "Google", Premium: false},
	{ID: "google/gemma-3-12b-it", Name: "Gemma 3 12B", Provider: "Google", Premium: false},
	{ID: "openai/gpt-5.4-nano", Name: "GPT-5.4 Nano", Provider: "OpenAI", Premium: true},
	{ID: "openai/gpt-5-nano", Name: "GPT-5 Nano", Provider: "OpenAI", Premium: true},
	{ID: "openai/gpt-4.1-nano", Name: "GPT-4.1 Nano", Provider: "OpenAI", Premium: true},
	{ID: "openai/gpt-oss-120b", Name: "GPT OSS 120B", Provider: "OpenAI", Premium: false},
	{ID: "openai/gpt-oss-20b", Name: "GPT OSS 20B", Provider: "OpenAI", Premium: false},
	{ID: "z-ai/glm-4.7-flash", Name: "GLM 4.7 Flash", Provider: "Z.AI", Premium: false},
	{ID: "z-ai/glm-4.7", Name: "GLM 4.7", Provider: "Z.AI", Premium: true},
	{ID: "z-ai/glm-4.6", Name: "GLM 4.6", Provider: "Z.AI", Premium: true},
	{ID: "z-ai/glm-4.5", Name: "GLM 4.5", Provider: "Z.AI", Premium: true},
	{ID: "minimax/minimax-m3", Name: "MiniMax M3", Provider: "MiniMax", Premium: true},
	{ID: "minimax/minimax-m2.7", Name: "MiniMax M2.7", Provider: "MiniMax", Premium: true},
	{ID: "minimax/minimax-m2.5", Name: "MiniMax M2.5", Provider: "MiniMax", Premium: true},
	{ID: "minimax/minimax-m2.1", Name: "MiniMax M2.1", Provider: "MiniMax", Premium: true},
	{ID: "minimax/minimax-m2-her", Name: "MiniMax M2-her", Provider: "MiniMax", Premium: true},
	{ID: "minimax/minimax-m2", Name: "MiniMax M2", Provider: "MiniMax", Premium: true},
	{ID: "ibm-granite/granite-4.1-8b", Name: "Granite 4.1 8B", Provider: "IBM", Premium: false},
	{ID: "ibm-granite/granite-4.0-h-micro", Name: "Granite 4 Micro", Provider: "IBM", Premium: false},
	{ID: "inclusionai/ling-2.6-flash", Name: "Ling 2.6 Flash", Provider: "InclusionAI", Premium: false},
	{ID: "inclusionai/ring-2.6-1t", Name: "Ring 2.6 1T", Provider: "InclusionAI", Premium: true},
	{ID: "tencent/hy3-preview", Name: "Hy3 Preview", Provider: "Tencent", Premium: true},
	{ID: "tencent/hunyuan-a13b-instruct", Name: "Hunyuan A13B Instruct", Provider: "Tencent", Premium: true},
	{ID: "qwen/qwen3.6-35b-a3b", Name: "Qwen3.6 35B", Provider: "Qwen", Premium: true},
	{ID: "stepfun/step-3.7-flash", Name: "Step 3.7 Flash", Provider: "StepFun", Premium: true},
	{ID: "baidu/ernie-4.5-21b-a3b", Name: "ERNIE-4.5 21B", Provider: "Baidu", Premium: true},
	{ID: "alibaba/tongyi-deepresearch-30b-a3b", Name: "Tongyi Deep Research 30B", Provider: "Alibaba", Premium: true},
	{ID: "meituan/longcat-flash-chat", Name: "Longcat Flash Chat", Provider: "Meituan", Premium: true},
	{ID: "bytedance-seed/seed-2.0-mini", Name: "Seed 2.0 mini", Provider: "ByteDance", Premium: true},
	{ID: "mistralai/mistral-small-2603", Name: "Mistral 4 Small", Provider: "MistralAI", Premium: true},
	{ID: "rekaai/reka-edge", Name: "Reka Edge", Provider: "RekaAI", Premium: true},
	{ID: "inception/mercury-2", Name: "Mercury 2", Provider: "Inception", Premium: true},
}

type Model struct {
	ID string `json:"id"`
	Name string `json:"name"`
	Provider string `json:"provider"`
	Premium bool `json:"premium"`
}

type Message struct {
	Role string `json:"role"`
	Content string `json:"content"`
}

type Payload struct {
	Package string `json:"package"`
	UUID string `json:"uuid"`
	Edition string `json:"edition"`
	Subscription string `json:"subscription"`
	OrderID string `json:"order_id"`
	LastPurchaseDate string `json:"last_purchase_date"`
	AIModel string `json:"ai_model"`
	Messages []Message `json:"messages"`
	TokenUsage int `json:"token_usage"`
	ThreadCharCount int `json:"thread_char_count"`
	IsPremium bool `json:"is_premium"`
	CurrentLanguage string `json:"current_language"`
	AppVersion string `json:"app_version"`
	RequestDate string `json:"request_date"`
	RequestTime int64 `json:"request_time"`
	FirstInstall int64 `json:"first_install"`
	Version string `json:"version"`
	SessionRequests int `json:"session_requests"`
	CurrentSessionAds int `json:"current_session_ads"`
	AndroidID string `json:"android_id"`
	HwFp string `json:"hw_fp"`
	IsRooted bool `json:"is_rooted"`
	IsEmulator bool `json:"is_emulator"`
	TZ string `json:"tz"`
	Currency string `json:"currency"`
	Country string `json:"country"`
	GPAID string `json:"gpa_id"`
	Extra string `json:"extra"`
}

type ChatResponse struct {
	Response string `json:"response"`
	Model string `json:"model"`
	Messages []Message `json:"messages"`
}

type ErrorResponse struct {
	Success bool `json:"success"`
	Message string `json:"message"`
}

type MimoCrypto struct{}

func (MimoCrypto) Obfuscate(text string) string {
	if text == "" {
		return ""
	}

	inputBytes := []byte(text)
	xorBytes := make([]byte, len(inputBytes))

	for i := 0; i < len(inputBytes); i++ {
		xorBytes[i] = inputBytes[i] ^ ENCRYPTION_KEY[i%len(ENCRYPTION_KEY)]
	}

	return base64.StdEncoding.EncodeToString(xorBytes) + "\n"
}

func (MimoCrypto) SignRequest(rawJson string, timestamp string) string {
	h := hmac.New(sha256.New, ENCRYPTION_KEY)
	h.Write([]byte(rawJson + ":" + timestamp))
	return base64.StdEncoding.EncodeToString(h.Sum(nil))
}

func (MimoCrypto) MakeUUID(installTime int64, edition string) string {
	if edition == "" {
		edition = "full_edition"
	}

	bytes := make([]byte, 16)
	rand.Read(bytes)
	hexStr := hex.EncodeToString(bytes)

	parts := []string{
		hexStr[0:8],
		hexStr[8:12],
		hexStr[12:16],
		hexStr[16:20],
		hexStr[20:32],
	}
	uuidFormat := strings.Join(parts, "-")
	return fmt.Sprintf("user_fi-%d_uu-%s_pa-mimo_ed-%s_apv-3_anv-android__14__API__34)", installTime, uuidFormat, edition)
}

func RandomHex(length int) string {
	bytes := make([]byte, length)
	rand.Read(bytes)
	return hex.EncodeToString(bytes)
}

type MimoAI struct {
	UserAgent string
	DefaultModel string
	Crypto MimoCrypto
}

func NewMimoAI(config map[string]string) *MimoAI {
	ua := "Neo/1.0"
	model := "xiaomi/mimo-v2.5-pro"

	if val, ok := config["userAgent"]; ok {
		ua = val
	}
	if val, ok := config["defaultModel"]; ok {
		model = val
	}

	return &MimoAI{
		UserAgent: ua,
		DefaultModel: model,
		Crypto: MimoCrypto{},
	}
}

func (c *MimoAI) FetchModels() ([]Model, error) {
	client := &http.Client{Timeout: 5 * time.Second}
	req, err := http.NewRequest("GET", "https://apps.clemy.top/ai/mimo/models.json", nil)
	if err != nil {
		return MODEL_REGISTRY, err
	}
	req.Header.Set("User-Agent", c.UserAgent)

	resp, err := client.Do(req)
	if err != nil {
		return MODEL_REGISTRY, nil
	}
	defer resp.Body.Close()

	var data struct {
		Models []Model `json:"models"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		return MODEL_REGISTRY, nil
	}

	if len(data.Models) > 0 {
		return data.Models, nil
	}
	return MODEL_REGISTRY, nil
}

func (c *MimoAI) SendMessage(params map[string]interface{}) (*ChatResponse, error) {
	prompt, _ := params["prompt"].(string)
	messages, _ := params["messages"].([]Message)
	model, _ := params["model"].(string)
	onStream, _ := params["onStream"].(func(string))

	if model == "" {
		model = c.DefaultModel
	}

	currentTime := time.Now().UnixMilli()
	installedTime := currentTime - 86400000

	conversationHistory := messages
	if prompt != "" {
		conversationHistory = append(conversationHistory, Message{Role: "user", Content: prompt})
	}

	charCount := 0
	for _, msg := range conversationHistory {
		charCount += len(msg.Content)
	}

	payload := Payload{
		Package: c.Crypto.Obfuscate("info.camposha.mimo"),
		UUID: c.Crypto.Obfuscate(c.Crypto.MakeUUID(installedTime, "full_edition")),
		Edition: c.Crypto.Obfuscate("full_edition"),
		Subscription: c.Crypto.Obfuscate("monthly"),
		OrderID: "GPA.3312-4567-8901-23456",
		LastPurchaseDate: "2026-08-01",
		AIModel: c.Crypto.Obfuscate(model),
		Messages: conversationHistory,
		TokenUsage: 0,
		ThreadCharCount: charCount,
		IsPremium: true,
		CurrentLanguage: c.Crypto.Obfuscate("in"),
		AppVersion: c.Crypto.Obfuscate("3"),
		RequestDate: c.Crypto.Obfuscate(time.Now().Format("2006-01-02")),
		RequestTime: currentTime,
		FirstInstall: installedTime,
		Version: c.Crypto.Obfuscate("android__14__API__34)"),
		SessionRequests:  1,
		CurrentSessionAds: 0,
		AndroidID: c.Crypto.Obfuscate(RandomHex(8)),
		HwFp: c.Crypto.Obfuscate(RandomHex(16)),
		IsRooted: false,
		IsEmulator: false,
		TZ: c.Crypto.Obfuscate("Asia/Jakarta"),
		Currency: c.Crypto.Obfuscate("IDR"),
		Country: c.Crypto.Obfuscate("ID"),
		GPAID: "GPA.3312-4567-8901-23456",
		Extra: "",
	}

	payloadJson, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	payloadStr := string(payloadJson)
	timestampStr := strconv.FormatInt(currentTime, 10)
	signature := c.Crypto.SignRequest(payloadStr, timestampStr)

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://aiv1.clemy.top/chat-completion-stream", bytes.NewBuffer(payloadJson))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Accept", "text/event-stream")
	req.Header.Set("Content-Type", "application/json; charset=utf-8")
	req.Header.Set("X-Signature", signature)
	req.Header.Set("X-Timestamp", timestampStr)
	req.Header.Set("User-Agent", c.UserAgent)

	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	fullText := ""
	reader := bufio.NewReader(resp.Body)

	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, err
		}

		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "data: ") {
			dataStr := strings.TrimPrefix(line, "data: ")
			if dataStr == "[DONE]" {
				continue
			}

			var parsedData struct {
				Choices []struct {
					Delta struct {
						Content string `json:"content"`
					} `json:"delta"`
				} `json:"choices"`
			}

			if err := json.Unmarshal([]byte(dataStr), &parsedData); err != nil {
				continue
			}

			if len(parsedData.Choices) > 0 {
				deltaContent := parsedData.Choices[0].Delta.Content
				if deltaContent != "" {
					fullText += deltaContent
					if onStream != nil {
						onStream(deltaContent)
					}
				}
			}
		}
	}

	finalReply := strings.TrimSpace(fullText)
	conversationHistory = append(conversationHistory, Message{Role: "assistant", Content: finalReply})

	return &ChatResponse{
		Response: finalReply,
		Model: model,
		Messages: conversationHistory,
	}, nil
}

func runDemo() {
	config := map[string]string{
		"userAgent": "Neo/1.0",
		"defaultModel": "xiaomi/mimo-v2.5-pro",
	}
	client := NewMimoAI(config)

	fmt.Println("=== MEMULAI TEST MIMO AI ===")

	fmt.Println("\n-> Pesan 1 [MiMo V2.5 PRO] (Streaming):")
	fmt.Print("Bot: ")

	result1, err := client.SendMessage(map[string]interface{}{
		"prompt": "halo! siapa namamu dan siapa pembuatmu? jawab singkat aja",
		"model": "xiaomi/mimo-v2.5-pro",
		"onStream": func(chunk string) {
			fmt.Print(chunk)
		},
	})
	if err != nil {
		fmt.Printf("\nError: %v\n", err)
		return
	}
	fmt.Println("\n")

	fmt.Println("-> Pesan 2 [DeepSeek v4 PRO] (Streaming And Konteks):")
	fmt.Print("Bot: ")

	result2, err := client.SendMessage(map[string]interface{}{
		"prompt": "bagus, sekarang buatkan satu baris pantun jenaka berdasarkan jawabanmu tadi",
		"messages": result1.Messages,
		"model": "deepseek/deepseek-v4-pro",
		"onStream": func(chunk string) {
			fmt.Print(chunk)
		},
	})
	if err != nil {
		fmt.Printf("\nError: %v\n", err)
		return
	}
	fmt.Println("\n")

	fmt.Println("=== TEST COMPLETE ===")
}

func main() {
	args := os.Args[1:]

	if len(args) > 0 {
		prompt := strings.Join(args, " ")
		config := map[string]string{
			"userAgent": "Neo/1.0",
			"defaultModel": "xiaomi/mimo-v2.5-pro",
		}
		client := NewMimoAI(config)

		fmt.Printf("Prompt: %s\n", prompt)
		fmt.Print("Response: ")

		result, err := client.SendMessage(map[string]interface{}{
			"prompt": prompt,
			"onStream": func(chunk string) {
				fmt.Print(chunk)
			},
		})
		if err != nil {
			fmt.Printf("\nError: %v\n", err)
			errorResp := ErrorResponse{
				Success: false,
				Message: err.Error(),
			}
			json.NewEncoder(os.Stdout).Encode(errorResp)
			os.Exit(1)
		}

		fmt.Println("\n")
		json.NewEncoder(os.Stdout).Encode(result)
	} else {
		runDemo()
	}
}