(ns advent.screens.rooms
  (:require [advent.zone :as zone]
            [advent.utils :as utils])
  (:import [com.badlogic.gdx.graphics Pixmap Pixmap$Filter Texture Texture$TextureFilter]
           [com.badlogic.gdx.graphics.g2d TextureRegion]
           [com.badlogic.gdx.utils.viewport FitViewport]
           [com.badlogic.gdx.scenes.scene2d Actor Stage]
           [java.lang Object]))

(defn make-entity [id {:keys [scripts script only-script] :as entity}]
  (merge entity
         {:id id
          :mouse-in? (fn [entities x y]
                       (let [e (utils/get-entity entities id)]
                         (if-let [[bx1 by1 bx2 by2] (:box e)]
                           (zone/within bx1 by1 bx2 by2 x y)
                           (let [{^float entity-x :x ^float entity-y :y width :width scale-x :scale-x scale-y :scale-y origin-x :origin-x origin-y :origin-y height :height region :object} (-> entities :room :entities id) 
                                 
                                 width (or width (if (instance? TextureRegion region ) (.getRegionWidth ^TextureRegion region) 0))
                                 height (or height (if (instance? TextureRegion region ) (.getRegionHeight ^TextureRegion region) 0))
                                 entity-x (double (unchecked-add (float entity-x) (unchecked-multiply (float -1.0)
                                                                                                      (unchecked-multiply (float (or origin-x 0))
                                                                                                                          (float (or scale-x 1))))))
                                 entity-y (double (unchecked-add (float entity-y) (unchecked-multiply
                                                                                   (float -1.0)
                                                                                   (unchecked-multiply (float (or origin-y 0))
                                                                                                       (float (or scale-y 1))))))]
                             
                             (zone/within entity-x entity-y
                                          (unchecked-add (float entity-x) (unchecked-multiply (float width) (float (or scale-x 1))))
                                          (unchecked-add (float entity-y) (unchecked-multiply (float height) (float (or scale-y 1))))
                                          x y)))))}
         (when (or script scripts only-script)
           {:get-script (fn [cursor [x y]]
                          (cond only-script
                                only-script

                                (= :main cursor)
                                script

                                scripts
                                (or (scripts (:value cursor)) (scripts :default))

                                :else
                                nil)
                          )})))
(defn make [& {:keys [collision interactions entities] :as params}]
  (let [interactions-as-list (for [[id {:keys [script scripts only-script box] :as spec}] interactions]
                               (merge spec
                                      (when box
                                        {:mouse-in? (fn [_ x y]
                                                      (let [[bx1 by1 bx2 by2] box]
                                                        (zone/within bx1 by1 bx2 by2 x y)))})
                                      (when (or script scripts only-script)
                                        {:get-script (fn [cursor [x y]]
                                                       (cond only-script
                                                             only-script

                                                             (= :main cursor)
                                                             script

                                                             scripts
                                                             (or (scripts (:value cursor)) (scripts :default))

                                                             :else
                                                             nil)
                                                       )})
                                      {:id id}))
        entities (into {} (for [[id entity] entities]
                            [id (make-entity id entity)]))]
    (merge params {:collision (advent.pathfind/map-from-resource collision)
                   :interactions interactions-as-list
                   :entities entities})))