(ns advent.screens.safe
  (:require [play-clj.core :refer :all]
            [play-clj.ui :refer :all]
            [play-clj.utils :refer :all]
            [play-clj.g2d :refer :all]
            
            [advent.pathfind]
            [advent.zone :as zone]
            [advent.utils :as utils])
  (:import [com.badlogic.gdx.graphics Pixmap Pixmap$Filter Texture Texture$TextureFilter]
           [com.badlogic.gdx.utils.viewport FitViewport]
           [com.badlogic.gdx.graphics.g2d TextureRegion]
           [com.badlogic.gdx.utils Align]
           [com.badlogic.gdx Application Audio Files Game Gdx Graphics Input
            InputMultiplexer InputProcessor Net Preferences Screen]))


(def start-x 35)
(def start-y 83)

(defn close [entities]
  
  (screen! @(resolve 'advent.screens.scene/scene) :on-reactivate {})
  (screen! @(resolve 'advent.screens.scene/scene) :on-end-safe {})
  (-> entities
      (assoc :shown? false)
      (assoc :start-showing? false)))

(defn button-box [x y]
  (zone/box (+ start-x x) (+ start-y y) (+ start-x x 30) (+ start-y y 36)))

(defn get-button [[x y]]
  (first (filter (fn [{:keys [in?] :as button}] 
                   (when (in? x y)
                     button))
                 [{:in? (button-box 6 16) :sound (utils/load-sound "inside-house/safe-1.ogg") :id 1 }
                  {:in? (button-box 43 16) :sound (utils/load-sound "inside-house/safe-2.ogg") :id 2}
                  {:in? (button-box 76 16) :sound (utils/load-sound "inside-house/safe-3.ogg") :id 3}
                  {:in? (button-box 118 16) :sound (utils/load-sound "inside-house/safe-4.ogg") :id 4}
                  {:in? (button-box 155 16) :sound (utils/load-sound "inside-house/safe-5.ogg") :id 5}])))

(defscreen safe-screen
  :on-show
  (fn [screen entities options]
    (utils/setup-viewport screen 320 240)
    
    (let [[screen atlas] (utils/acquire-atlas screen "packed/global.atlas")
          inputed-key (utils/atlas->texture atlas "safe/inputed-key.png")]
      {:fade (assoc (utils/atlas->texture atlas "black.png")
               :scale-x 80
               :scale-y 80 
               :opacity 0.7
               :origin-x 0
               :origin-y 0)
       :safe (assoc (utils/atlas->texture atlas "safe/safe-screen") :x start-x :y start-y)
       :entered-keys (doall (for [i (range 5)]
                              (assoc inputed-key
                                    :x (+ start-x 12 (* i 12))
                                    :y (+ start-y 68))))
       :shown? false}))

  
  :on-render
  (fn [{:keys [^FitViewport viewport] :as screen} entities options]
    (.apply viewport)
    (when (:shown? entities)
      (render! screen [(:fade entities) (:safe entities)])
      (render! screen (take (count (:button-choices entities)) (:entered-keys entities))))
    entities)

  :show-screen (fn [_ entities {:keys [success failure]}]
                 (sound! (utils/load-sound "inside-house/open-safe.ogg") :play (utils/current-sound-volume 0.3))
                 (assoc entities
                   :shown? true
                   :button-choices []
                   :success success
                   :failure failure))

  :on-mouse-moved (fn [screen entities options]
                    entities)

  :on-touch-up (fn [screen entities options]
                   (when (:shown? entities)
                     (let [[x y] (utils/unproject screen options)]
                       (if-let [button (get-button [x y])]
                         (do (sound! (:sound button) :play (utils/current-sound-volume 0.3))
                             (let [new-state (update-in entities [:button-choices] #(conj % (:id button)))]

                               (cond (= [4 2 1 5 3] (:button-choices new-state))
                                     (do ((:success entities) (-> @(resolve 'advent.screens.scene/scene)
                                                                  :entities
                                                                  deref))
                                         (close entities))
                                     (= 5 (count (:button-choices new-state)))
                                     (do ((:failure entities) (-> @(resolve 'advent.screens.scene/scene)
                                                                  :entities
                                                                  deref))  
                                         (close entities))
                                     :else
                                     new-state)))
                         (if (or (< x start-x)
                                 (> x (+ start-x 250))
                                 (< y start-y)
                                 (> y (+ start-y 100)))
                           (do
                             (sound! (utils/load-sound "inside-house/close-safe.ogg") :play (utils/current-sound-volume 0.3))
                             (close entities)))))))
  
  :on-resize (fn [{:keys [^FitViewport viewport]} entities {:keys [width height]}]
               (.update viewport width height)))