main.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"image/color"
	"io"
	"log"
	"net/http"
	"os"
	"regexp"
	"strings"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
	"github.com/joho/godotenv"
)

type PixelData struct {
	Data [][]int `json:"data"`
}

var (
	apiKey = " "
	apiUrl = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key="
)

var generateButton *widget.Button

func fetchPixelData(prompt string) (*PixelData, error) {
	if prompt == "" {
		return nil, fmt.Errorf("input cannot be empty")
	}

	systemInstruction := `Generate a JSON response containing a **high-detail 2D boolean matrix representation** of an object based on the given input: "{object_name}".  

	### **Output Format (ALWAYS JSON)**:
	{
		"data": [
			[0, 0, 1, 1, 1, 0, 0, 0, 1, 1],
			[0, 1, 1, 1, 1, 1, 0, 1, 1, 1],
			[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
			[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
			[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
			[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
			[0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
			[0, 0, 1, 1, 1, 1, 1, 1, 0, 0]
		]
	}
	### Rules:
	- Always return output as a valid JSON object.
	- The "data" field must contain a nested list of integers (0 or 1) with a grid size between 10x10 and 20x20.
	- Ensure that the pixel representation closely matches the given "{object_name}".
	- Do not add any explanation outside of the JSON response.

	Now, generate the binary matrix for: **"{object_name}"**`

	requestData := map[string]any{
		"contents": []map[string]any{
			{"role": "user", "parts": []map[string]string{{"text": prompt}}},
		},
		"systemInstruction": map[string]any{
			"role":  "system",
			"parts": []map[string]string{{"text": systemInstruction}},
		},
	}

	requestBody, err := json.Marshal(requestData)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", apiUrl+apiKey, bytes.NewBuffer(requestBody))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	response, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}

	var apiResponse map[string]any
	if err := json.Unmarshal(body, &apiResponse); err != nil {
		return nil, err
	}

	candidates, ok := apiResponse["candidates"].([]any)
	if !ok || len(candidates) == 0 {
		return nil, fmt.Errorf("invalid response format")
	}

	content, ok := candidates[0].(map[string]any)["content"].(map[string]any)
	if !ok {
		return nil, fmt.Errorf("missing content field")
	}

	parts, ok := content["parts"].([]any)
	if !ok || len(parts) == 0 {
		return nil, fmt.Errorf("invalid parts data")
	}

	responseText, _ := parts[0].(map[string]any)["text"].(string)
	cleanedText := strings.TrimSpace(responseText)
	regex := regexp.MustCompile("^```json\\n|```$")
	cleanedText = regex.ReplaceAllString(cleanedText, "")
	//	log.Println("Cleaned Text:", cleanedText)
	var pixelData PixelData
	if err := json.Unmarshal([]byte(cleanedText), &pixelData); err != nil {
		return nil, err
	}

	return &pixelData, nil
}

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}
	apiKey = os.Getenv("API_KEY")
	application := app.New()
	window := application.NewWindow("AI BIT Map Gen")
	window.Resize(fyne.NewSize(500, 600))

	message := widget.NewLabel("This AI can draw 2D art shapes")
	inputPrompt := widget.NewEntry()
	inputPrompt.SetPlaceHolder("Enter object name...")

	gridContainer := container.NewWithoutLayout()

	generateButton = widget.NewButton("Generate", func() {
		message.SetText("Generating image...")
		gridContainer.Objects = nil
		gridContainer.Refresh()

		pixelData, err := fetchPixelData(inputPrompt.Text)
		if err != nil {
			log.Println("Error:", err)
			message.SetText("Failed to generate image. Try again.")
			return
		}

		message.SetText("Image generated successfully!")
		inputPrompt.SetText("")
		var tiles []fyne.CanvasObject

		tileSize := 20
		offsetX := 10
		offsetY := 10

		for rowIdx, row := range pixelData.Data {
			for colIdx, col := range row {
				if col == 1 {
					x := offsetX + (colIdx * tileSize)
					y := offsetY + (rowIdx * tileSize)
					rect := rectDraw(x, y)
					rect.FillColor = color.NRGBA{R: 0xff, G: 0x33, B: 0x33, A: 0xff}
					tiles = append(tiles, rect)
				}
			}
		}

		gridContainer.Objects = tiles
		gridContainer.Refresh()
	})

	window.SetContent(container.NewVBox(
		message,
		inputPrompt,
		generateButton,
		gridContainer,
	))
	window.ShowAndRun()
}

func rectDraw(x int, y int) *canvas.Rectangle {
	blue := color.NRGBA{R: 0, G: 0, B: 180, A: 255}
	rect := canvas.NewRectangle(blue)
	rect.Move(fyne.NewPos(float32(x), float32(y)))
	rect.Resize(fyne.NewSize(20, 20))
	return rect
}