package main

import (
	"context"
	"fmt"
	"os"

	"github.com/PullRequestInc/go-gpt3"
)

func onErrPanic(err *error) {
	if *err != nil {
		panic((*err).Error())
	}
}

func generate() (err error) {
	defer onErrPanic(&err)

	ctx := context.Background()
	client := gpt3.NewClient("your own api key")

	var completion string

	content := fmt.Sprintf(`
-- This is the postgresql schema

%v


-- here are the queries. They have a name, annotated by ":name". They
-- also have another tag that represents how many rows should be returned.
-- :one means that only one row is expected to be returned
-- :many means that more than one row will be returned

%v


-- Write go functions that consume the previous queries. You won't write queries using a specific driver.
-- Rather, the queries will be provided an interface that abstracts the database.
-- That interface won't have a constructor. You won't write a main function. You won't write comments. The
-- package will be main.
`, exampleSchema, exampleQueries)

	err = client.ChatCompletionStream(ctx, gpt3.ChatCompletionRequest{
		Model: gpt3.GPT3Dot5Turbo,
		Messages: []gpt3.ChatCompletionRequestMessage{
			{
				Role:    "system",
				Content: `You are a command line tool that generates golang code contacting the database. You only output go code, nothing else`,
			},
			{
				Role: "user",
				Content: content,
			},
		},
		Temperature:      0, // note this, temperature is set to 0
		Stream:           true,
		MaxTokens:        1000,
	}, func(res *gpt3.ChatCompletionStreamResponse) {
		fmt.Print(res.Choices[0].Delta.Content)
		completion += res.Choices[0].Delta.Content
	})
	if err != nil {
		return err
	}

	fmt.Println()

	return nil
}

var exampleSchema = `
CREATE TABLE authors (
    id   BIGSERIAL PRIMARY KEY,
    name text      NOT NULL,
    bio  text
);
`

var exampleQueries = `
-- name: GetAuthor :one
SELECT * FROM authors
WHERE id = $1 LIMIT 1;
`

func main() {
	generate()
}