package contract

import (
    "context"
    "net/http"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/dto"
)

type ProductScraperRepository interface {
    FindProducts(context.Context) ([]domain.Product, error)
}

type ProductDataBaseRepository interface {
    Fetch(context.Context) ([]domain.Product, error)
    Create(context.Context, domain.Product) (*domain.Product, error)
}

type ProductScraperUseCase interface {
    SeedProducts(context.Context) ([]domain.Product, error)
}

type ProductUseCase interface {
    GetMenu(context.Context) (*string, error)
    SearchForTips(context.Context) (*dto.AlexaResponse, error)
}

type ProductLLMRepository interface {
    GetMenu(context.Context, []domain.Product) (*string, error)
}

type ProductController interface {
    SearchForTips(http.ResponseWriter, *http.Request)
}

type ProductCLI interface {
    SeedProducts(context.Context)
}

package repository

import (
    "context"
    "strconv"
    "strings"
    "time"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/playwright-community/playwright-go"
)

const (
    DIDIOS_SITE = "https://didios.menudino.com/"
)

type didiosRepository struct {
    scrapper *playwright.Playwright
}

// FindProducts implements contract.ProductScraperRepository.
func (repository *didiosRepository) FindProducts(context.Context) ([]domain.Product, error) {
    products := []domain.Product{}

    browser, err := repository.scrapper.Chromium.Launch(playwright.BrowserTypeLaunchOptions{
        Headless: playwright.Bool(true),
    })
    if err != nil {
        return nil, err
    }

    context, err := browser.NewContext()
    if err != nil {
        return nil, err
    }

    page, err := context.NewPage()
    if err != nil {
        return nil, err
    }

    _, err = page.Goto(DIDIOS_SITE)
    if err != nil {
        return nil, err
    }

    categories, err := page.Locator("#cardapio > section.cardapio-body > div > div.categories > div").All()
    if err != nil {
        return nil, err
    }

    for _, category := range categories {
        category.ScrollIntoViewIfNeeded()

        time.Sleep(time.Millisecond * 500)

        cards, err := category.Locator("div:nth-child(2) > div > div").All()
        if err != nil {
            return nil, err
        }

        for _, card := range cards {
            card.ScrollIntoViewIfNeeded()

            productName, err := card.Locator("a > div > div.media-body > div.name > span").TextContent()
            if err != nil {
                return nil, err
            }

            productPrice, err := card.Locator("a > div > div.media-body > div.priceDescription > div").TextContent()
            if err != nil {
                return nil, err
            }

            productPrice = strings.ReplaceAll(productPrice, "R$ ", "")
            productPrice = strings.ReplaceAll(productPrice, ",", ".")

            product := domain.Product{
                Name:    productName,
                Company: "DIDIOS",
            }

            if price, err := strconv.ParseFloat(productPrice, 64); err == nil {
                product.Price = price
            }

            products = append(products, product)
        }
    }

    return products, nil
}

func NewDidiosRepository(scraper *playwright.Playwright) contract.ProductScraperRepository {
    return &didiosRepository{
        scrapper: scraper,
    }
}

package repository

import (
    "bytes"
    "context"
    "fmt"
    "log"
    "text/tabwriter"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/google/generative-ai-go/genai"
)

type geminiRepository struct {
    client *genai.Client
}

// GetMenu implements contract.ProductLLMRepository.
func (repository *geminiRepository) GetMenu(ctx context.Context, products []domain.Product) (*string, error) {
    model := repository.client.GenerativeModel("gemini-1.5-pro")

    chatSession := model.StartChat()

    var b bytes.Buffer

    writer := tabwriter.NewWriter(&b, 0, 8, 1, '\t', tabwriter.AlignRight)
    for _, product := range products {
        fmt.Fprintf(writer, "ID: %v\tNome: %s\tPreço: %v\tEmpresa: %s\n", product.ID, product.Name, product.Price, product.Company)
    }
    writer.Flush()

    prompt := fmt.Sprintf(` 
    Você é um atendente de restaurante.
    Sempre monte um cardápio para pedir em qualquer hora segundo essa lista de produtos: %s.
    Informe o que seria ideal pedir para comer e o preço total da compra.
    Detalhe de qual empresa é cada produto, bem como seu nome e preço.
    Mostre três opções de pedidos.
    Não dê mais informações do que o necessário.
    Sempre seja gentil.
    Seja sucinto!
    Você pode misturar os produtos de todas as empresas, se quiser.
    Diversifique sempre os pedidos para não ser toda vez a mesma coisa.
    Coloque uma pequena frase legal no final.
    Escreva os números por extenso sempre.
    Escreva tudo por extenso para leitura da Alexa.
    Escreva tudo em uma frase, respeitando o portugues.
    Não coloque caracteres especiais.
    Fale sempre em primeira pessoa.
                                                 `, b.String())

    res, err := chatSession.SendMessage(ctx, genai.Text(prompt))
    if err != nil {
        log.Fatal(err)
    }

    output := ""

    for _, cand := range res.Candidates {
        if cand.Content != nil {
            for _, part := range cand.Content.Parts {
                output = fmt.Sprintf("%s %s", output, part)
            }
        }
    }

    fmt.Println(output)

    return &output, nil
}

func NewGeminiRepository(client *genai.Client) contract.ProductLLMRepository {
    return &geminiRepository{
        client: client,
    }
}

package database

import (
    "context"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/jmoiron/sqlx"
)

type productDatabaseRepository struct {
    database *sqlx.DB
}

// Create implements contract.ProductDataBaseRepository.
func (repository *productDatabaseRepository) Create(ctx context.Context, input domain.Product) (*domain.Product, error) {
    output := domain.Product{}
    query := "INSERT INTO product (name, price, company, inserted_at) VALUES ($1, $2, $3, $4) RETURNING *;"

    err := repository.database.QueryRowxContext(
        ctx,
        query,
        input.Name,
        input.Price,
        input.Company,
        input.InsertedAt,
    ).StructScan(&output)
    if err != nil {
        return nil, err
    }

    return &output, nil
}

// Fetch implements contract.ProductDataBaseRepository.
func (repository *productDatabaseRepository) Fetch(ctx context.Context) ([]domain.Product, error) {
    output := []domain.Product{}
    query := `
        SELECT p.* FROM product p
        INNER JOIN (
            SELECT  MAX(inserted_at) AS MAXDATE
            FROM product
        ) p2
        ON p.inserted_at = p2.MAXDATE
    `

    err := repository.database.SelectContext(ctx, &output, query)
    if err != nil {
        return nil, err
    }

    return output, nil
}

func NewProductDatabase(database *sqlx.DB) contract.ProductDataBaseRepository {
    return &productDatabaseRepository{database: database}
}

package usecase

import (
    "context"
    "slices"
    "time"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
)

type scraperUsecase struct {
    didiosRepository          contract.ProductScraperRepository
    potatosRepository         contract.ProductScraperRepository
    productDatabaseRepository contract.ProductDataBaseRepository
}

// SeedProducts implements contract.ProductScraperUseCase.
func (usecase *scraperUsecase) SeedProducts(ctx context.Context) ([]domain.Product, error) {
    currenteDate := time.Now()
    productsCreated := []domain.Product{}

    potatosProducts, err := usecase.potatosRepository.FindProducts(ctx)
    if err != nil {
        return nil, err
    }

    didiosProducts, err := usecase.didiosRepository.FindProducts(ctx)
    if err != nil {
        return nil, err
    }

    products := slices.Concat(potatosProducts, didiosProducts)

    for _, product := range products {
        product.InsertedAt = currenteDate
        productCreated, err := usecase.productDatabaseRepository.Create(ctx, product)
        if err != nil {
            return nil, err
        }

        productsCreated = append(productsCreated, *productCreated)
    }

    return productsCreated, nil
}

func NewProductScraperUsecase(
    didiosRepository contract.ProductScraperRepository,
    potatosRepository contract.ProductScraperRepository,
    productDatabaseRepository contract.ProductDataBaseRepository,
) contract.ProductScraperUseCase {
    return &scraperUsecase{
        didiosRepository:          didiosRepository,
        potatosRepository:         potatosRepository,
        productDatabaseRepository: productDatabaseRepository,
    }
}