package org.jadv.client;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.jadv.framework.Model;
import org.jadv.model.level.Level;

/**
 * Model of the Application Window.
 */
@Getter
@Setter
@ToString
public class ApplicationModel extends Model {

    /**
     * Current level
     */
    private Level level;

    /**
     * ScaleFactor in percent
     */
    private int scaleFactor = 100;

    /**
     * X Coordinate of level in upper left corner
     */
    private int x = 0;

    /**
     * Y coordinate of level in upper left corner
     */
    private int y = 0;

    /**
     * Store for images
     */
    @Setter
    private ImageStore imageStore;
}

public class ImageStore {

    private final Map<String, Image> images = new HashMap<>();

    public Image getImage(String name) {
        return images.get(name);
    }
}

package org.jadv.client;

import org.jadv.framework.View;

import javax.swing.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

/**
 * Application View
 */
public class ApplicationView extends View implements KeyListener {

    /**
     * Window of this game view.
     */
    private JFrame gameFrame;

    /**
     * Panel that displays the Level.
     */
    private LevelPanel levelPanel;

    /**
     * Gets the model with the data.
     * @return The model with the data that is shown inside the view.
     */
    @Override
    public ApplicationModel getModel() {
        return (ApplicationModel) model;
    }

    @Override
    public void init() {
        gameFrame = new JFrame("JAdventure v0.1");
        gameFrame.setSize(500, 400);
        gameFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        levelPanel = new LevelPanel(getModel());
        gameFrame.setContentPane(levelPanel);
        gameFrame.addKeyListener(this);
        levelPanel.setFocusable(true);
        gameFrame.setFocusable(true);
    }

    /**
     * Displays the window.
     */
    @Override
    public void show() {
        gameFrame.setVisible(true);
    }

    /**
     * Updates the view.
     */
    @Override
    protected void updateView() {
        super.updateView();
        gameFrame.repaint();
    }

    /**
     * Updates the model if required.
     */
    @Override
    protected void updateModel() {
        super.updateModel();
    }

    /**
     * Invoked when a key has been typed.
     * See the class description for {@link KeyEvent} for a definition of
     * a key typed event.
     *
     * @param e the event to be processed
     */
    @Override
    public void keyTyped(KeyEvent e) {
        switch (e.getKeyChar()) {
            case 'w' -> sendAction(ApplicationCommands.MOVE_UP);
            case 's' -> sendAction(ApplicationCommands.MOVE_DOWN);
            case 'a' -> sendAction(ApplicationCommands.MOVE_LEFT);
            case 'd' -> sendAction(ApplicationCommands.MOVE_RIGHT);
            case 'o' -> sendAction(ApplicationCommands.SCALE_IN);
            case 'p' -> sendAction(ApplicationCommands.SCALE_OUT);
        }
    }

    /**
     * Invoked when a key has been pressed.
     * See the class description for {@link KeyEvent} for a definition of
     * a key pressed event.
     *
     * @param e the event to be processed
     */
    @Override
    public void keyPressed(KeyEvent e) { }

    /**
     * Invoked when a key has been released.
     * See the class description for {@link KeyEvent} for a definition of
     * a key released event.
     *
     * @param e the event to be processed
     */
    @Override
    public void keyReleased(KeyEvent e) { }
}

package org.jadv.client;

import org.jadv.model.level.Level;
import org.jadv.model.objects.GameObject;

import javax.swing.*;
import java.awt.*;

public class LevelPanel extends JPanel {

    private final ApplicationModel model;

    /**
     * Creates a new <code>JPanel</code> with a double buffer
     * and a flow layout.
     */
    public LevelPanel(ApplicationModel model) {
        this.model = model;
    }

    /**
     * Calls the UI delegate's paint method, if the UI delegate
     * is non-<code>null</code>.  We pass the delegate a copy of the
     * <code>Graphics</code> object to protect the rest of the
     * paint code from irrevocable changes
     * (for example, <code>Graphics.translate</code>).
     * <p>
     * If you override this in a subclass you should not make permanent
     * changes to the passed in <code>Graphics</code>. For example, you
     * should not alter the clip <code>Rectangle</code> or modify the
     * transform. If you need to do these operations you may find it
     * easier to create a new <code>Graphics</code> from the passed in
     * <code>Graphics</code> and manipulate it. Further, if you do not
     * invoke super's implementation you must honor the opaque property, that is
     * if this component is opaque, you must completely fill in the background
     * in an opaque color. If you do not honor the opaque property you
     * will likely see visual artifacts.
     * <p>
     * The passed in <code>Graphics</code> object might
     * have a transform other than the identify transform
     * installed on it.  In this case, you might get
     * unexpected results if you cumulatively apply
     * another transform.
     *
     * @param g the <code>Graphics</code> object to protect
     * @see #paint
     */
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        checkViewPoint();

        Graphics2D g2d = (Graphics2D) g;
        g2d.setBackground(Color.BLACK);
        g2d.clearRect(0,0, getWidth(), getHeight());


        Level level = model.getLevel();

        drawImage(g2d, level.getGraphicResource(), level.getWidth()/2, level.getHeight()/2, level.getWidth(), level.getHeight(), model.getScaleFactor(), model.getX(), model.getY());

        for (GameObject object : level.getChildren()) {
            drawImage(g2d, object.getGraphicResource(), object.getPosition().getX(), object.getPosition().getY(), object.getSize().getWidth(), object.getSize().getHeight(), model.getScaleFactor(), model.getX(), model.getY());
        }
    }

    /**
     * Checks that the ViewPoint is valid.
     */
    private void checkViewPoint() {
        int realHeight = model.getLevel().getHeight() * model.getScaleFactor() / 100;
        int realWidth = model.getLevel().getWidth() * model.getScaleFactor() / 100;

        // To move: Calculate x/y
        int maxY = realHeight - getHeight();
        int maxX = realWidth - getWidth();
        int currY = model.getY() * model.getScaleFactor() / 100;
        int currX = model.getX() * model.getScaleFactor() / 100;
        if (maxY < currY && 0 <= maxY) model.setY(maxY * 100 / model.getScaleFactor());
        if (maxX < currX && 0 <= maxX) model.setX(maxX * 100 / model.getScaleFactor());
    }

    private void drawImage(Graphics g, String imgName, int x, int y, int dx, int dy, int scale, int viewX, int viewY) {
        Image img = model.getImageStore().getImage(imgName);
        if (img == null) return;

        int newX = scale * (x - viewX - dx/2) / 100;
        int newY = scale * (y - viewY - dy/2) / 100;
        int newDx = scale * dx / 100;
        int newDy = scale * dy / 100;

        g.drawImage(img, newX, newY, newDx, newDy, null);
    }

}

package org.jadv.client;

import org.jadv.model.level.Level;
import org.jadv.model.objects.GameObject;
import org.jadv.services.ImageService;

import java.awt.*;
import java.util.HashMap;
import java.util.Map;

public class ImageStore {

    private final ImageService imageService;

    /**
     * Store for all Images
     */
    private final Map<String, Image> images = new HashMap<>();

    public ImageStore(ImageService imageService) {
        this.imageService = imageService;
    }

    /**
     * Checks if an image is already inside the Map.
     * @param name Name of the image.
     * @return true if the image is inside the map, else false.
     */
    public boolean hasImage(String name) {
        return images.containsKey(name);
    }

    /**
     * Gets the image of a given name.
     * @param name Name of the image.
     * @return The image if available else null.
     */
    public Image getImage(String name) {
        return images.get(name);
    }

    /**
     * Adds an image to the store, if an image with that name already exists, then the image is replaced.
     * @param name Name of image.
     * @param image Image to put in store.
     */
    public void addImage(String name, Image image) {
        images.put(name, image);
    }

    /**
     * Checks all images used by a level and loads missing images.
     * @param level Level to check.
     */
    public void checkAndLoadImages(Level level) {
        checkAndLoadImage(level.getGraphicResource());

        for (GameObject child: level.getChildren()) {
            checkAndLoadImage(child.getGraphicResource());
        }
    }

    /**
     * Checks and loads Images if required.
     * @param name Name of the image.
     */
    public void checkAndLoadImage(String name) {
        if (hasImage(name)) return;

        Image image = imageService.loadImage(name);
        if (image != null) addImage(name, image);
    }

}

package org.jadv.client;

import org.jadv.framework.Controller;
import org.jadv.model.level.Level;
import org.jadv.services.ImageService;
import org.jadv.services.LevelService;

/**
 * Controller of the Application Window.
 */
public class ApplicationController extends Controller {

    /**
     * Start level to load.
     */
    public static final String START_LEVEL = "testlevel";

    /**
     * ImageService to load images.
     */
    private final ImageService imageService;

    /**
     * LevelService to load level.
     */
    private final LevelService levelService;

    /**
     * Creates a new instance of ApplicationController
     * @param imageService ImageService to use to load images.
     * @param levelService LevelService to use to load level.
     */
    public ApplicationController(ImageService imageService, LevelService levelService) {
        super(new ApplicationModel(), new ApplicationView());
        this.imageService = imageService;
        this.levelService = levelService;
        getModel().setImageStore(new ImageStore(imageService));
    }

    /**
     * Load data and show View.
     */
    public void show() {
        loadModel();
        view.show();
    }

    /**
     * Loads the data into the view.
     */
    private void loadModel() {
        Level level = levelService.loadLevel(START_LEVEL);
        if (level == null) throw new IllegalStateException("Unable to load Level " + START_LEVEL + "!");

        // Set level
        getModel().setLevel(level);

        // Set scale factor
        getModel().setScaleFactor(100);

        // Set Corner
        getModel().setX(0);
        getModel().setY(0);

        getModel().getImageStore().checkAndLoadImages(level);
    }

    @Override
    public ApplicationView getView() {
        return (ApplicationView) view;
    }

    @Override
    public ApplicationModel getModel() {
        return (ApplicationModel) model;
    }

    @Override
    public void handleAction(Object action) {
        if (action instanceof ApplicationCommands command) {
            doCommand(command);
        }
    }

    protected void move(int dx, int dy) {
        getModel().setX(Math.max(0, getModel().getX() + dx * getModel().getScaleFactor()/100));
        getModel().setY(Math.max(0, getModel().getY() + dy * getModel().getScaleFactor()/100));
        getModel().hasChanged();
    }

    protected void scale(int ds) {
        int newScale = getModel().getScaleFactor() + ds;

        if (newScale < 25) newScale = 25;
        if (newScale > 1000) newScale = 10000;

        getModel().setScaleFactor(newScale);
        getModel().hasChanged();
    }

    private void doCommand(ApplicationCommands command) {
        switch (command) {
            case MOVE_UP -> move(0, -20);
            case MOVE_DOWN -> move(0, 20);
            case MOVE_LEFT -> move(-20, 0);
            case MOVE_RIGHT -> move(20, 0);
            case SCALE_OUT -> scale(10);
            case SCALE_IN -> scale(-10);
        }
    }

}

package org.jadv.client;

import org.jadv.services.ImageService;
import org.jadv.services.LevelService;

/**
 * Main of the JAdventure Client..
 */
public class Main {

    /**
     * Startpoint of the JAdventure client.
     * @param args Commandline arguments, not used.
     */
    public static void main(String[] args) {
        ImageService imageService = new ImageService();
        LevelService levelService = new LevelService();
        ApplicationController controller =  new ApplicationController(imageService, levelService);
        controller.show();
    }
}