import RetroSprite from "./RetroSprite.js";
import RetroArchitectureTile from "./RetroArchitectureTile.js";
import GeometryRectCollection from "../geometry/GeometryRectCollection.js";
import GeometryPoint from "../geometry/GeometryPoint.js";
import GeometryRect from "../geometry/GeometryRect.js";
import GraphicSet from "../GraphicSet.js";
import Setting from "../Setting.js";

export default class RetroArchitecture
{
    constructor(tilesetSprite, tiles, columns, rows)
    {
        this.tileset = tilesetSprite;
        this.tiles = tiles;
        this.backgroundColor = null;
        this.backgroundImage = null;
        this.rows = rows;
        this.columns = columns;
        this.matrix = [];
        this.tileWidth = this.tileset.getWidth() / this.tiles;
        this.tileHeight = this.tileset.getHeight();
        this.startX = 0;
        this.startY = 0;
        this.targetX = 0;
        this.targetY = 0;
        this.targetPosition = new GeometryPoint(this.targetX, this.targetY);

        this.init();
    }

    init()
    {
        for (let y = 0; y < this.rows; y++) {
            let row = [];

            for (let x = 0; x < this.columns; x++) {
                row.push(null);
            }

            this.matrix.push(row);
        }
    }

    setBackgroundColor(color)
    {
        this.backgroundColor = color;
    }

    setBackgroundImage(image)
    {
        this.backgroundImage = image;
    }

    getCollisionRects(rect)
    {
        let posX = Math.floor(rect.position.x / this.tileWidth) - 2;
        let posY = Math.floor(rect.position.y / this.tileHeight) - 2;
        let rangeX = parseInt( posX + rect.width / this.tileWidth) + 4;
        let rangeY = parseInt(posY + rect.height / this.tileHeight) + 4;

        let collection = new GeometryRectCollection();

        for (let y = Math.max(0, posY); y < rangeY; y++) {
            for (let x = Math.max(0, posX); x < rangeX; x++) {
                if (y < this.matrix.length && x < this.matrix[y].length && this.matrix[y][x] !== null) {
                    let intersection = this.matrix[y][x].rect.getRectIntersection(rect);
                    if (intersection !== null) {
                        collection.addRect(intersection);
                    }
                }
            }
        }

        return collection;
    }

    hasRectCollision(rect)
    {
        let posX = Math.floor(rect.position.x / this.tileWidth) - 2;
        let posY = Math.floor(rect.position.y / this.tileHeight) - 2;
        let rangeX = parseInt( posX + rect.width / this.tileWidth) + 4;
        let rangeY = parseInt(posY + rect.height / this.tileHeight) + 4;

        for (let y = Math.max(0, posY); y < rangeY; y++) {
            for (let x = Math.max(0, posX); x < rangeX; x++) {
                if (this.matrix[y][x] !== null) {
                    if (this.matrix[y][x].rect.getRectIntersection(rect) !== null) {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    getTileForPosition(position, offsetX = 0, offsetY = 0)
    {
        let x = parseInt(position.x / this.tileWidth) + offsetX;
        let y = parseInt(position.y / this.tileHeight) + offsetY;

        if (x < 0 || x >= this.columns || y < 0 || y >= this.rows) {
            return null;
        }

        return new GeometryPoint(x, y);
    }

    getCeilingHeight(position)
    {
        let tilePosition = this.getTileForPosition(position, 0);

        while (tilePosition !== null && tilePosition.y > 0) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.y * this.tileHeight + this.tileHeight;
            }

            tilePosition.y--;
        }

        return 0;
    }

    getGroundHeight(position)
    {
        let tilePosition = this.getTileForPosition(position);

        while (tilePosition !== null && tilePosition.y < this.rows) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.y * this.tileHeight;
            }

            tilePosition.y++;
        }

        return (this.rows + 10)  * this.tileHeight;
    }

    getWallRight(position)
    {
        let tilePosition = this.getTileForPosition(new GeometryPoint(position.x, position.y), 1, 0);

        while (tilePosition !== null && tilePosition.x < this.columns) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.x * this.tileWidth;
            }

            tilePosition.x++;
        }

        return this.tileWidth * this.columns;
    }

    getWallLeft(position)
    {
        let tilePosition = this.getTileForPosition(new GeometryPoint(position.x, position.y), -1,0);

        while (tilePosition !== null && tilePosition.x > 0) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.x * this.tileWidth + this.tileWidth;
            }

            tilePosition.x--;
        }

        return 0;
    }

    isInsideArchitecture(geometryPoint)
    {
        let architectureRect = new GeometryRect(
            0, 0, this.tileWidth * this.columns, this.tileHeight * this.rows
        );

        return architectureRect.isContainingPoint(geometryPoint);
    }

    setMovableToStartPosition(movable)
    {
        movable.position.x = this.tileWidth * this.startX + this.tileWidth * 0.5;
        movable.position.y = this.tileHeight * this.startY + this.tileHeight * 0.5;
    }

    setMovableToTargetPosition(movable)
    {
            movable.position.x = this.tileWidth * this.targetX + this.tileWidth * 0.5;
            movable.position.y = this.tileHeight * this.targetY + this.tileHeight;
    }

    isMovableInsideTargetPosition(movable)
    {
        let tileRect = new GeometryRect(
            this.targetX * this.tileWidth,
            this.targetY * this.tileHeight,
            this.tileWidth,
            this.tileHeight
        );

        return tileRect.isContainingPoint(movable.getPositionHeadLeft()) ||
            tileRect.isContainingPoint(movable.getPositionHeadRight()) ||
            tileRect.isContainingPoint(movable.getPositionFootLeft()) ||
            tileRect.isContainingPoint(movable.getPositionFootRight());
    }

    draw(context, camera = null)
    {
        let viewX = parseInt(Math.floor(Math.max(0, camera.position.x) / this.tileWidth));
        let viewWidth = parseInt(Math.min(Math.ceil(camera.width), this.columns));
        let viewY = parseInt(Math.floor(Math.max(0, camera.position.y)) / this.tileHeight);
        let viewHeight = parseInt(Math.min(Math.ceil(camera.height), this.rows));

        for (let y = viewY; y < viewHeight; y++) {
            for (let x = viewX; x < viewWidth; x++) {
                let field = this.matrix[y][x];

                if (field !== null && field !== undefined) {
                    this.drawField(context, x, y, camera, field);
                }
            }
        }
    }

    drawField(context, x, y, camera, field)
    {
        context.drawImage(
            this.tileset.canvas,
            field.tile * this.tileWidth,
            0,
            this.tileWidth,
            this.tileHeight,
            x * this.tileWidth - camera.position.x,
            y * this.tileHeight - camera.position.y,
            this.tileWidth + 1,
            this.tileHeight + 1
        );
    }

    static createFromData(data)
    {
        let graphicSet = GraphicSet[data.tileset];
        console.log(data);
        let tileset = new RetroSprite(
            Setting.TILESET_LOCATION + graphicSet.tileset,
            graphicSet.scale
        );

        let architecture = new RetroArchitecture(
            tileset,
            graphicSet.tiles,
            data.columns,
            data.rows
        );

        architecture.setBackgroundColor(graphicSet.backgroundColor);
        architecture.setBackgroundImage(graphicSet.backgroundImage);

        architecture.startX = data.startX;
        architecture.startY = data.startY;
        architecture.targetX = data.targetX;
        architecture.targetY = data.targetY;
        architecture.targetPosition = new GeometryPoint(data.targetX, data.targetY);

        for (let y = 0; y < data.rows; y++) {
            for (let x = 0; x < data.columns; x++) {
                if (data.matrix[y][x] > -1) {
                    architecture.matrix[y][x] = new RetroArchitectureTile(
                        data.matrix[y][x],
                        x * architecture.tileWidth,
                        y * architecture.tileHeight,
                        architecture.tileWidth,
                        architecture.tileHeight
                    )
                }
            }
        }

        return architecture;
    }
}