package springai;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Description;

import java.util.function.Function;

@SpringBootApplication
public class SpringOllama implements CommandLineRunner {
    public static void main(String[] args) {
        SpringApplication.run(SpringOllama.class);
    }

    @Autowired
    ChatModel chatModel;

    public static class MockCalculate {
        public record Request(Double n1, Double n2) {
        }

        public record Response(Double r) {
        }
    }

    public static class MockCalculateAdd implements Function<MockCalculate.Request, MockCalculate.Response> {

        public MockCalculate.Response apply(MockCalculate.Request request) {
            System.out.println("add request: " + request);
            return new MockCalculate.Response(request.n1 + request.n2);
        }
    }

    public static class MockCalculateMultiply implements Function<MockCalculate.Request, MockCalculate.Response> {

        public MockCalculate.Response apply(MockCalculate.Request request) {
            System.out.println("mul request: " + request);
            return new MockCalculate.Response(request.n1 * request.n2);
        }
    }

    public static class MockCalculateDivide implements Function<MockCalculate.Request, MockCalculate.Response> {

        public MockCalculate.Response apply(MockCalculate.Request request) {
            System.out.println("div request: " + request);
            return new MockCalculate.Response(request.n1 / request.n2);
        }
    }

    @Bean
    @Description("calculate sum")
    public Function<MockCalculate.Request, MockCalculate.Response> add() {
        return new MockCalculateAdd();
    }

    @Bean
    @Description("calculate multiplication")
    public Function<MockCalculate.Request, MockCalculate.Response> multiply() {
        return new MockCalculateMultiply();
    }

    @Bean
    @Description("calculate divide")
    public Function<MockCalculate.Request, MockCalculate.Response> divide() {
        return new MockCalculateDivide();
    }

    @Override
    public void run(String... args) {
        ChatClient.Builder builder = ChatClient.builder(chatModel);
        ChatClient chatClient = builder.build();
        ChatClient.CallResponseSpec responseSpec = chatClient.prompt()
                .system("you are a calculate, you need analyze the user input, and solve it step by step, use the tools to calculate the value.")
                .user("hello, what is 30 increase 47%")
                .functions("add", "multiply", "divide")
                .call();
        System.out.println(responseSpec.content());
        System.exit(0);
    }
}

plugins {
	id 'java'
	id 'org.springframework.boot' version '3.2.4'
	id 'io.spring.dependency-management' version '1.1.4'
}

group = 'org.bk.langchain4j'
version = '0.0.1-SNAPSHOT'

java {
	sourceCompatibility = '21'
}

ext {
	langchain4jVersion = "0.32.0"
}

repositories {
	mavenCentral()
	maven { url 'https://repo.spring.io/milestone' }
	maven { url 'https://repo.spring.io/snapshot' }
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation 'org.springframework.session:spring-session-core'
	implementation 'org.springframework.ai:spring-ai-ollama'
	implementation 'org.springframework.ai:spring-ai-ollama-spring-boot-starter'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
	implementation platform("org.springframework.ai:spring-ai-bom:1.0.0-SNAPSHOT")
}

tasks.named('test') {
	useJUnitPlatform()
}

spring:
  ai:
    ollama:
      chat:
        options:
          model: "llama3.1"

add request: Request[n1=0.47, n2=30.0]
add request: Request[n1=14.1, n2=30.0]
To calculate the increase of 47% on 30, I will use the following steps:

1. First, I need to convert the percentage into a decimal by dividing it by 100: 47 / 100 = 0.47
2. Then, I will multiply the original value (30) by this decimal: 30 * 0.47 = 14.1
3. Finally, I will add this result to the original value: 30 + 14.1 = 44.1

Therefore, 30 increased by 47% is equal to 44.10.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;

public class Tetris extends JFrame {

    private static final int BOARD_WIDTH = 10;
    private static final int BOARD_HEIGHT = 22;

    private Timer timer;
    private boolean isFallingFinished = false;
    private boolean isStarted = false;
    private boolean isPaused = false;
    private int numLinesRemoved = 0;
    private int curX = 0;
    private int curY = 0;
    private JLabel statusbar;
    private Shape curPiece;
    private Tetrominoes[] board;

    public Tetris() {
        initUI();
    }

    private void initUI() {
        statusbar = new JLabel(" 0");
        add(statusbar, BorderLayout.SOUTH);
        Board board = new Board(this);
        add(board);
        board.start();

        setTitle("Tetris");
        setSize(200, 400);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            Tetris game = new Tetris();
            game.setVisible(true);
        });
    }

    JLabel getStatusBar() {
        return statusbar;
    }

    class Board extends JPanel implements ActionListener {

        private final int BOARD_WIDTH = 10;
        private final int BOARD_HEIGHT = 22;
        private Timer timer;
        private boolean isFallingFinished = false;
        private boolean isStarted = false;
        private boolean isPaused = false;
        private int numLinesRemoved = 0;
        private int curX = 0;
        private int curY = 0;
        private JLabel statusbar;
        private Shape curPiece;
        private Tetrominoes[] board;

        public Board(Tetris parent) {
            setFocusable(true);
            curPiece = new Shape();
            timer = new Timer(400, this);
            timer.start();

            statusbar = parent.getStatusBar();
            board = new Tetrominoes[BOARD_WIDTH * BOARD_HEIGHT];
            addKeyListener(new TAdapter());
            clearBoard();
        }

        public void start() {
            if (isPaused)
                return;

            isStarted = true;
            isFallingFinished = false;
            numLinesRemoved = 0;
            clearBoard();

            newPiece();
            timer.start();
        }

        private void pause() {
            if (!isStarted)
                return;

            isPaused = !isPaused;

            if (isPaused) {
                timer.stop();
                statusbar.setText("paused");
            } else {
                timer.start();
                statusbar.setText(String.valueOf(numLinesRemoved));
            }

            repaint();
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            if (isFallingFinished) {
                isFallingFinished = false;
                newPiece();
            } else {
                oneLineDown();
            }
        }

        private int squareWidth() {
            return (int) getSize().getWidth() / BOARD_WIDTH;
        }

        private int squareHeight() {
            return (int) getSize().getHeight() / BOARD_HEIGHT;
        }

        private Tetrominoes shapeAt(int x, int y) {
            return board[(y * BOARD_WIDTH) + x];
        }

        private void clearBoard() {
            for (int i = 0; i < BOARD_HEIGHT * BOARD_WIDTH; i++) {
                board[i] = Tetrominoes.NoShape;
            }
        }

        private void pieceDropped() {
            for (int i = 0; i < 4; i++) {
                int x = curX + curPiece.x(i);
                int y = curY - curPiece.y(i);
                board[(y * BOARD_WIDTH) + x] = curPiece.getShape();
            }

            removeFullLines();

            if (!isFallingFinished) {
                newPiece();
            }
        }

        private void newPiece() {
            curPiece.setRandomShape();
            curX = BOARD_WIDTH / 2 + 1;
            curY = BOARD_HEIGHT - 1 + curPiece.minY();

            if (!tryMove(curPiece, curX, curY)) {
                curPiece.setShape(Tetrominoes.NoShape);
                timer.stop();
                isStarted = false;
                statusbar.setText("game over");
            }
        }

        private void oneLineDown() {
            if (!tryMove(curPiece, curX, curY - 1)) {
                pieceDropped();
            }
        }

        private boolean tryMove(Shape newPiece, int newX, int newY) {
            for (int i = 0; i < 4; i++) {
                int x = newX + newPiece.x(i);
                int y = newY - newPiece.y(i);

                if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
                    return false;

                if (shapeAt(x, y) != Tetrominoes.NoShape)
                    return false;
            }

            curPiece = newPiece;
            curX = newX;
            curY = newY;
            repaint();

            return true;
        }

        private void drawSquare(Graphics g, int x, int y, Tetrominoes shape) {
            Color colors[] = {
                    new Color(0, 0, 0), new Color(204, 102, 102),
                    new Color(102, 204, 102), new Color(102, 102, 204),
                    new Color(204, 204, 102), new Color(204, 102, 204),
                    new Color(102, 204, 204), new Color(218, 170, 0)
            };

            Color color = colors[shape.ordinal()];

            g.setColor(color);
            g.fillRect(x + 1, y + 1, squareWidth() - 2, squareHeight() - 2);

            g.setColor(color.brighter());
            g.drawLine(x, y + squareHeight() - 1, x, y);
            g.drawLine(x, y, x + squareWidth() - 1, y);

            g.setColor(color.darker());
            g.drawLine(x + 1, y + squareHeight() - 1,
                    x + squareWidth() - 1, y + squareHeight() - 1);
            g.drawLine(x + squareWidth() - 1, y + squareHeight() - 1,
                    x + squareWidth() - 1, y + 1);
        }

        private void removeFullLines() {
            int numFullLines = 0;

            for (int i = BOARD_HEIGHT - 1; i >= 0; i--) {
                boolean lineIsFull = true;

                for (int j = 0; j < BOARD_WIDTH; j++) {
                    if (shapeAt(j, i) == Tetrominoes.NoShape) {
                        lineIsFull = false;
                        break;
                    }
                }

                if (lineIsFull) {
                    numFullLines++;
                    for (int k = i; k < BOARD_HEIGHT - 1; k++) {
                        for (int j = 0; j < BOARD_WIDTH; j++) {
                            board[(k * BOARD_WIDTH) + j] = shapeAt(j, k + 1);
                        }
                    }
                }
            }

            if (numFullLines > 0) {
                numLinesRemoved += numFullLines;
                statusbar.setText(String.valueOf(numLinesRemoved));
                isFallingFinished = true;
                curPiece.setShape(Tetrominoes.NoShape);
                repaint();
            }
        }

        @Override
        public void paint(Graphics g) {
            super.paint(g);

            Dimension size = getSize();
            int boardTop = (int) size.getHeight() - BOARD_HEIGHT * squareHeight();

            for (int i = 0; i < BOARD_HEIGHT; i++) {
                for (int j = 0; j < BOARD_WIDTH; j++) {
                    Tetrominoes shape = shapeAt(j, BOARD_HEIGHT - i - 1);

                    if (shape != Tetrominoes.NoShape) {
                        drawSquare(g, j * squareWidth(),
                                boardTop + i * squareHeight(), shape);
                    }
                }
            }

            if (curPiece.getShape() != Tetrominoes.NoShape) {
                for (int i = 0; i < 4; i++) {
                    int x = curX + curPiece.x(i);
                    int y = curY - curPiece.y(i);
                    drawSquare(g, x * squareWidth(),
                            boardTop + (BOARD_HEIGHT - y - 1) * squareHeight(),
                            curPiece.getShape());
                }
            }
        }

        private class TAdapter extends KeyAdapter {
            @Override
            public void keyPressed(KeyEvent e) {
                if (!isStarted || curPiece.getShape() == Tetrominoes.NoShape) {
                    return;
                }

                int keycode = e.getKeyCode();

                if (keycode == 'p' || keycode == 'P') {
                    pause();
                    return;
                }

                if (isPaused) {
                    return;
                }

                switch (keycode) {
                    case KeyEvent.VK_LEFT:
                        tryMove(curPiece, curX - 1, curY);
                        break;
                    case KeyEvent.VK_RIGHT:
                        tryMove(curPiece, curX + 1, curY);
                        break;
                    case KeyEvent.VK_DOWN:
                        tryMove(curPiece.rotateRight(), curX, curY);
                        break;
                    case KeyEvent.VK_UP:
                        tryMove(curPiece.rotateLeft(), curX, curY);
                        break;
                    case KeyEvent.VK_SPACE:
                        dropDown();
                        break;
                    case 'd':
                        oneLineDown();
                        break;
                }
            }
        }

        private void dropDown() {
            int newY = curY;

            while (newY > 0) {
                if (!tryMove(curPiece, curX, newY - 1)) {
                    break;
                }
                --newY;
            }

            pieceDropped();
        }
    }

}
enum Tetrominoes {NoShape, ZShape, SShape, LineShape, TShape, SquareShape, LShape, MirroredLShape}

class Shape {

    private Tetrominoes pieceShape;
    private int coords[][];
    private int[][][] coordsTable;

    public Shape() {
        coords = new int[4][2];
        setShape(Tetrominoes.NoShape);
    }

    public void setShape(Tetrominoes shape) {
        coordsTable = new int[][][]{
                {{0, 0}, {0, 0}, {0, 0}, {0, 0}},
                {{0, -1}, {0, 0}, {-1, 0}, {-1, 1}},
                {{0, -1}, {0, 0}, {1, 0}, {1, 1}},
                {{0, -1}, {0, 0}, {0, 1}, {0, 2}},
                {{-1, 0}, {0, 0}, {1, 0}, {0, 1}},
                {{0, 0}, {1, 0}, {0, 1}, {1, 1}},
                {{-1, -1}, {0, -1}, {0, 0}, {0, 1}},
                {{1, -1}, {0, -1}, {0, 0}, {0, 1}}
        };

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 2; ++j) {
                coords[i][j] = coordsTable[shape.ordinal()][i][j];
            }
        }

        pieceShape = shape;
    }

    private void setX(int index, int x) {
        coords[index][0] = x;
    }

    private void setY(int index, int y) {
        coords[index][1] = y;
    }

    public int x(int index) {
        return coords[index][0];
    }

    public int y(int index) {
        return coords[index][1];
    }

    public Tetrominoes getShape() {
        return pieceShape;
    }

    public void setRandomShape() {
        Random r = new Random();
        int x = Math.abs(r.nextInt()) % 7 + 1;
        Tetrominoes[] values = Tetrominoes.values();
        setShape(values[x]);
    }

    public int minX() {
        int m = coords[0][0];
        for (int i = 0; i < 4; i++) {
            m = Math.min(m, coords[i][0]);
        }
        return m;
    }

    public int minY() {
        int m = coords[0][1];
        for (int i = 0; i < 4; i++) {
            m = Math.min(m, coords[i][1]);
        }
        return m;
    }

    public Shape rotateLeft() {
        if (pieceShape == Tetrominoes.SquareShape)
            return this;

        Shape result = new Shape();
        result.pieceShape = pieceShape;

        for (int i = 0; i < 4; ++i) {
            result.setX(i, y(i));
            result.setY(i, -x(i));
        }
        return result;
    }

    public Shape rotateRight() {
        if (pieceShape == Tetrominoes.SquareShape)
            return this;

        Shape result = new Shape();
        result.pieceShape = pieceShape;

        for (int i = 0; i < 4; ++i) {
            result.setX(i, -y(i));
            result.setY(i, x(i));
        }
        return result;
    }
}