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";
import Camera from "../Camera.js";
import Level from "../Level.js";

export default class RetroArchitecture
{
    /**
     * @param {{sprite: RetroSprite, tiles: number}} retroTileset
     * @param {number} columns 
     * @param {number} rows
     * @param {{sprite: RetroSprite, tiles: number}} retroTilesetBackground
     */
    constructor(retroTileset, columns, rows, retroTilesetBackground = null)
    {
        /** @type {RetroSprite} */
        this.tilesetSprite = retroTileset.sprite;

        /** @type {RetroSprite|null} */
        this.tilesetSpriteBackground = retroTilesetBackground !== null 
            ? retroTilesetBackground.sprite
            : null;

        /** @type {number} */
        this.tiles = retroTileset.tiles;

        /** @type {number} */
        this.tilesBackground = retroTilesetBackground !== null 
            ? retroTilesetBackground.tiles
            : 0;

        /** @type {string|null} */
        this.backgroundColor = null;

        /** @type {string|null} */
        this.backgroundImage = null;

        /** @type {number} */
        this.rows = rows;

        /** @type {number} */
        this.columns = columns;

        /** @type {Array<Array<RetroArchitectureTile>>} */
        this.matrix = [];

        /** @type {number} */
        this.tileWidth = this.tilesetSprite.getWidth() / this.tiles;

        /** @type {number} */
        this.tileHeight = this.tilesetSprite.getHeight();

        /** @type {number} */
        this.startX = 0;

        /** @type {number} */
        this.startY = 0;

        /** @type {number} */
        this.targetX = 0;

        /** @type {number} */
        this.targetY = 0;

        /** @type {GeometryPoint} */
        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);
        }
    }

    /**
     * @param {string|null} color 
     */
    setBackgroundColor(color)
    {
        this.backgroundColor = color;
    }

    /**
     * @param {string|null} image 
     */
    setBackgroundImage(image)
    {
        this.backgroundImage = image;
    }

    /**
     * @param {GeometryRect} rect 
     * @returns {GeometryRectCollection}
     */
    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 && this.matrix[y][x].tile.index > -1
                ) {
                    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 && this.matrix[y][x].tile.index > -1) {
                    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 &&
                this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
            ) {
                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 &&
                this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
            ) {
                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  &&
                this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
            ) {
                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 && 
                this.matrix[tilePosition.y][tilePosition.x].tile.index > -1
            ) {
                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 = new Camera())
    {
        const viewX = parseInt(Math.floor(Math.max(0, camera.position.x) / this.tileWidth));
        const viewWidth = parseInt(Math.min(Math.ceil(camera.width), this.columns));
        const viewY = parseInt(Math.floor(Math.max(0, camera.position.y)) / this.tileHeight);
        const 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.tile.index === -1) {
                    continue;
                }

                if (field.tile.index > -1) {
                    this.drawField(context, x, y, camera, field);
                } else {
                    this.drawBackgroundField(context, x, y, camera, field);
                }
            }
        }
    }

    drawField(context, x, y, camera, field)
    {
        context.drawImage(
            this.tilesetSprite.canvas,
            (field.tile.index % this.tiles) * this.tileWidth,
            0,
            this.tileWidth,
            this.tileHeight,
            Math.round(x * this.tileWidth - camera.position.x),
            Math.round(y * this.tileHeight - camera.position.y),
            this.tileWidth,
            this.tileHeight,
        );
    }

    drawBackgroundField(context, x, y, camera, field)
    {
        context.drawImage(
            this.tilesetSpriteBackground.canvas,
            -((field.tile.index + 2) % this.tilesBackground) * this.tileWidth,
            0,
            this.tileWidth,
            this.tileHeight,
            Math.round(x * this.tileWidth - camera.position.x),
            Math.round(y * this.tileHeight - camera.position.y),
            this.tileWidth,
            this.tileHeight,
        );
    }

    getStartPosition()
    {
        return new GeometryPoint(this.startX * this.tileWidth, this.startY * this.tileHeight);
    }

    /**
     * @param {Level} level 
     */
    static createFromData(level)
    {
        let graphicSet = GraphicSet[level.getTilesetId()];

        const tilesetSprite = new RetroSprite(
            Setting.TILESET_LOCATION + graphicSet.tileset,
            graphicSet.scale
        );

        const tilesetBackground = level.terrain.tileset.background !== null
            ? new RetroSprite(level.terrain.tileset.background.image.src)
            : null;

        const architecture = new RetroArchitecture(
            {sprite: tilesetSprite, tiles: graphicSet.tiles},
            level.getColumns(),
            level.getRows(),
            tilesetBackground === null ? null : {sprite: tilesetBackground, tiles: level.terrain.tileset.background.tiles}
        );

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

        architecture.startX = level.getStartX();
        architecture.startY = level.getStartY();
        architecture.targetX = level.getTargetX();
        architecture.targetY = level.getTargetY();
        architecture.targetPosition = new GeometryPoint(level.getTargetX(), level.getTargetY());

        for (let y = 0; y < level.getRows(); y++) {
            for (let x = 0; x < level.getColumns(); x++) {
                if (level.getTilesetMatrix()[y][x].index !== -1) {
                    architecture.matrix[y][x] = new RetroArchitectureTile(
                        level.getTilesetMatrix()[y][x],
                        x * architecture.tileWidth,
                        y * architecture.tileHeight,
                        architecture.tileWidth,
                        architecture.tileHeight
                    );
                }
            }
        }

        return architecture;
    }
}
