(ns neko.-utils
  (:require [clojure.string :as string])
  (:import [java.lang.reflect Method Constructor Field]))

(defmacro app-package-name
  []
  (:neko.init/package-name *compiler-options*))

(defmacro memoized
  [func-def]
  (let [fn-name (second func-def)]
    `(do ~func-def
         (let [meta# (meta (var ~fn-name))]
           (def ~fn-name (memoize ~fn-name))
           (reset-meta! (var ~fn-name) meta#)))))

(defn int-id
  [obj]
  (Math/abs (.hashCode ^Object obj)))

(defn simple-name
  [full-class-name]
  (nth (re-find #"(.*\.)?(.+)" (str full-class-name)) 2))

(defn capitalize
  [s]
  (str (.toUpperCase (subs s 0 1)) (subs s 1)))

(defn unicaseize
  [s]
  (str (.toLowerCase (subs s 0 1)) (subs s 1)))

(memoized
 (defn keyword->static-field
   [kw]
   (.toUpperCase (string/replace (name kw) \- \_))))

(defn keyword->camelcase
  [kw]
  (let [[first & rest] (string/split (name kw) #"-")]
    (string/join (cons first (map capitalize rest)))))

(memoized
 (defn keyword->setter
   [kw]
   (->> (keyword->camelcase kw)
        capitalize
        (str "set"))))

(defmacro call-if-nnil
  [f & arguments]
  `(if ~f
     (do (~f ~@arguments)
         true)
     false))

(defn class-or-type [cl]
  (condp = cl
    Boolean Boolean/TYPE
    Integer Integer/TYPE
    Long Integer/TYPE
    Double Double/TYPE
    Float Float/TYPE
    Character Character/TYPE
    cl))

(defn ^Method reflect-setter
  [^Class widget-type, ^String method-name, ^Class value-type]
  (if-not (= widget-type Object)
    (let [value-type (class-or-type value-type)
          all-value-types (cons value-type (supers value-type))]
      (loop [[t & r] all-value-types]
        (if t
          (if-let [method (try
                            (.getDeclaredMethod widget-type method-name
                                                (into-array Class [t]))
                            (catch NoSuchMethodException e nil))]
            method
            (recur r))
          (reflect-setter (.getSuperclass widget-type)
                          method-name value-type))))
    (throw
     (NoSuchMethodException. (format "Couldn't find method .%s for argument %s)"
                                     method-name (.getName value-type))))))

(defn ^Constructor reflect-constructor
  [^Class widget-type constructor-arg-types]
  (.getConstructor widget-type (into-array Class constructor-arg-types)))

(defn reflect-field
  [^Class widget-type, ^String field-name]
  (.get ^Field (.getDeclaredField widget-type field-name) nil))

(ns neko.action-bar
  (:require neko.ui)
  (:use [neko.ui.mapping :only [defelement]]
        [neko.ui.traits :only [deftrait]]
        [neko.-utils :only [call-if-nnil]])
  (:import [android.app ActionBar ActionBar$Tab ActionBar$TabListener]
           android.app.Activity android.app.Fragment android.R$id))

(defn tab-listener
  [& {:keys [on-tab-selected on-tab-unselected on-tab-reselected]}]
  (reify ActionBar$TabListener
    (onTabSelected [this tab ft]
      (call-if-nnil on-tab-selected tab ft))
    (onTabUnselected [this tab ft]
      (call-if-nnil on-tab-unselected tab ft))
    (onTabReselected [this tab ft]
      (call-if-nnil on-tab-reselected tab ft))))

(defn simple-tab-listener
  [tag, ^Fragment fragment]
  (reify ActionBar$TabListener
    (onTabReselected [this tab ft])
    (onTabUnselected [this tab ft]
      (when (.isAdded fragment)
        (.detach ft fragment)))
    (onTabSelected [this tab ft]
      (if (.isDetached fragment)
        (.attach ft fragment)
        (.add ft R$id/content fragment tag)))))

(defelement :action-bar
  :classname android.app.ActionBar
  :inherits nil
  :traits [:tabs :display-options]
  :values {:standard ActionBar/NAVIGATION_MODE_STANDARD
           :list ActionBar/NAVIGATION_MODE_LIST
           :tabs ActionBar/NAVIGATION_MODE_TABS})

(defelement :action-bar-tab
  :classname android.app.ActionBar$Tab
  :inherits nil
  :traits [:tab-listener])

(deftrait :tabs
  [^ActionBar action-bar, {:keys [tabs]} _]
  (doseq [[_ tab-attributes] tabs
          :let [tab (.newTab action-bar)]]
    (neko.ui/apply-attributes :action-bar-tab tab tab-attributes {})
    (.addTab action-bar tab)))

(defn display-options-value
  [value]
  (if (keyword? value)
    (case value
      :home-as-up  ActionBar/DISPLAY_HOME_AS_UP
      :show-home   ActionBar/DISPLAY_SHOW_HOME
      :show-custom ActionBar/DISPLAY_SHOW_CUSTOM
      :show-title  ActionBar/DISPLAY_SHOW_TITLE
      :use-logo    ActionBar/DISPLAY_USE_LOGO)
    value))

(deftrait :display-options
  [^ActionBar action-bar, {:keys [display-options]} _]
  (let [value (if (vector? display-options)
                (apply bit-or (map display-options-value display-options))
                (display-options-value display-options))]
    (.setDisplayOptions action-bar value)))

(deftrait :tab-listener
  [^ActionBar$Tab tab, {:keys [tab-listener]} _]
  (let [listener (if (instance? Fragment tab-listener)
                   (simple-tab-listener (str tab-listener) tab-listener)
                   tab-listener)]
    (.setTabListener tab listener)))

(defn setup-action-bar
  [^Activity activity, attributes-map]
  (let [action-bar (.getActionBar activity)]
    (neko.ui/apply-attributes :action-bar action-bar attributes-map {})))

(ns neko.activity
  (:require [clojure.string :as s]
            [neko.ui :refer [make-ui]]
            [neko.debug :refer [all-activities safe-for-ui]]
            [neko.-utils :as u])
  (:import android.app.Activity
           [android.view View Window]
           android.app.Fragment
           neko.ActivityWithState))

(defn ^View get-decor-view
  [^Activity activity]
  (.. activity getWindow getDecorView))

(defn set-content-view!
  [^Activity activity, view]
  {:pre [(instance? Activity activity)]}
  (cond
   (instance? View view)
   (.setContentView activity ^View view)
   (integer? view)
   (.setContentView activity ^Integer view)
   :else
   (let [dv (get-decor-view activity)]
     (.setTag dv (java.util.HashMap.))
     (.setContentView activity
                      ^View (neko.ui/make-ui-element activity view
                                                     {:id-holder dv})))))

(defmacro request-window-features!
  [^Activity activity & features]
  {:pre [(every? keyword? features)]}
  `[~@(for [feat features]
        `(.requestWindowFeature
          ~activity ~(symbol (str (.getName Window) "/FEATURE_"
                                  (u/keyword->static-field (name feat))))))])

(defmacro ^{:forms '[name & options & methods]} defactivity
  [name & args]
  (if (some #{:on-create} args)
    (throw
     (RuntimeException.
      (str "ERROR: This syntax of defactivity is deprecated, please "
           "update it to the new syntax: "
           "https://github.com/clojure-android/neko/wiki/Namespaces#defining-an-activity")))
    (let [[{:keys [extends implements prefix state key features]} methods]
          (loop [args args, options {}, methods {}]
            (cond (empty? args) [options methods]
                  (keyword? (first args))
                  (recur (drop 2 args)
                         (assoc options (first args) (second args))
                         methods)
                  :else
                  (recur (rest args) options
                         (assoc methods (ffirst args) (first args)))))
          sname (u/simple-name name)
          prefix (or prefix (str sname "-"))
          state (or state `(atom {}))]
      `(do
         (gen-class
          :name ~name
          :main false
          :prefix ~prefix
          :init "init"
          :state "state"
          :extends ~(or extends Activity)
          :implements ~(conj implements neko.ActivityWithState)
          :overrides-methods ~(conj (keys methods) 'getState)
          :exposes-methods {~'onCreate ~'superOnCreate
                            ~'onStart ~'superOnStart
                            ~'onRestart ~'superOnRestart
                            ~'onResume ~'superOnResume
                            ~'onPause ~'superOnPause
                            ~'onStop ~'superOnStop
                            ~'onCreateContextMenu ~'superOnCreateContextMenu
                            ~'onContextItemSelected ~'superOnContextItemSelected
                            ~'onCreateOptionsMenu ~'superOnCreateOptionsMenu
                            ~'onOptionsItemSelected ~'superOnOptionsItemSelected
                            ~'onActivityResult ~'superOnActivityResult
                            ~'onNewIntent ~'superOnNewIntent
                            ~'onDestroy ~'superOnDestroy})
         ~`(defn ~(symbol (str prefix "init"))
             [] [[] ~state])
         ~`(defn ~(symbol (str prefix "getState"))
             [~(vary-meta 'this assoc :tag name)]
             (.state ~'this))
         ~(when-let [[mname args & body] (get methods 'onCreate)]
            (let [[super-call body] (if (= (ffirst body) '.superOnCreate)
                                      [(first body) (rest body)]
                                      [nil body])]
              `(defn ~(symbol (str prefix mname))
                 [~(vary-meta (first args) assoc :tag name)
                  ~(vary-meta (second args) assoc :tag android.os.Bundle)]
                 ~super-call
                 (.put all-activities '~(.name *ns*) ~'this)
                 ~(when key
                    `(.put all-activities ~key ~'this))
                 ~(when features
                    `(request-window-features! ~'this ~@features))
                 (safe-for-ui ~@body))))
         ~@(for [[_ [mname args & body]] (dissoc methods 'onCreate)]
             `(defn ~(symbol (str prefix mname))
                [~(vary-meta (first args) assoc :tag name)
                 ~@(rest args)]
                (safe-for-ui ~@body)))))))

(defn get-state [^ActivityWithState activity]
  (.getState activity))

(defn simple-fragment
  ([context tree]
     (simple-fragment (make-ui context tree)))
  ([view]
     (proxy [Fragment] []
       (onCreateView [inflater container bundle]
         (if (instance? View view)
           view
           (do
             (println "One-argument version is deprecated. Please use (simple-fragment context tree)")
             (make-ui view)))))))

(ns neko.compliment.ui-widgets-and-attributes
  (:require [neko.ui.mapping :as mapping]
            [neko.ui.traits :as traits]
            [neko.doc :as doc]
            [neko.resource :as droid-res]
            [clojure.string :as string]
            [clojure.set :as set]))

(defn keyword-symbol?
  [x]
  (re-matches #":.*" x))

(defn process-context
  [context]
  (let [[level1 level2] context]
    (cond (and (vector? (:form level1)) (= (:idx level1) 0))
          {:type :widget}
          (and (map? (:form level1)) (= (:map-role level1) :key))
          {:type :attr,
           :widget (when (and (vector? (:form level2))
                              (= (:idx level2) 1))
                     (let [w-name (first (:form level2))]
                       (when (and (keyword? w-name)
                                  ((mapping/get-keyword-mapping) w-name))
                         w-name)))})))

(defn get-widget-attributes
  [widget-kw]
  (let [attributes (:attributes (meta #'neko.ui.traits/apply-trait))]
    (if widget-kw
      (let [all-traits (mapping/all-traits widget-kw)]
        (for [[att w-traits] attributes
              :when (not (empty? (set/intersection w-traits (set all-traits))))]
          att))
      (keys attributes))))

(defn candidates
  [^String prefix, ns context]
  (when (keyword-symbol? prefix)
    (let [ctx (process-context context)
          cands (cond
                 (nil? ctx) []
                 (= (:type ctx) :widget) (keys (mapping/get-keyword-mapping))
                 (= (:type ctx) :attr) (get-widget-attributes (:widget ctx)))]
      (for [^String kw-str (map str cands)
            :when (.startsWith kw-str prefix)]
        kw-str))))

(defn doc
  [^String symbol-str, ns]
  (when (keyword-symbol? symbol-str)
    (let [kw (keyword (subs symbol-str 1))
          kw-mapping (mapping/get-keyword-mapping)
          attributes (:attributes (meta #'neko.ui.traits/apply-trait))]
      (cond (kw-mapping kw)
            (doc/get-element-doc kw kw-mapping false)
            (attributes kw)
            (->> (attributes kw)
                 (map doc/get-trait-doc)
                 (interpose "\n\n")
                 string/join)))))

(defn init-source
  []
  (try (require 'compliment.core)
       ((resolve 'compliment.sources/defsource) ::neko-ui-keywords
        :candidates #'candidates
        :doc #'doc)
       (catch Exception ex nil)))

(ns neko.context
  {:author "Daniel Solano Gómez"}
  (:require [neko.-utils :as u])
  (:import android.content.Context
           neko.App))

(defmacro get-service
  {:pre [(keyword? type)]}
  ([type]
   `(get-service neko.App/instance ~type))
  ([context type]
   `(.getSystemService
     ^Context ~context
     ~(symbol (str (.getName Context) "/"
                   (u/keyword->static-field (name type)) "_SERVICE")))))

(ns neko.data
  (:import android.os.Bundle android.content.Intent
           android.content.SharedPreferences
           neko.App))

(deftype MapLikeBundle [^Bundle bundle]
  clojure.lang.Associative
  (containsKey [this k]
    (.containsKey bundle (name k)))
  (entryAt [this k]
    (clojure.lang.MapEntry. k (.get bundle (name k))))
  (valAt [this k]
    (.get bundle (name k)))
  (valAt [this k default]
    (let [key (name k)]
      (if (.containsKey bundle key)
        (.get bundle (name key))
        default)))
  (seq [this]
    (map (fn [k] [k (.get bundle k)])
         (.keySet bundle))))

(deftype MapLikeHashMap [^java.util.HashMap hmap]
  clojure.lang.Associative
  (containsKey [this k]
    (.containsKey hmap (name k)))
  (entryAt [this k]
    (clojure.lang.MapEntry. k (.get hmap (name k))))
  (valAt [this k]
    (.get hmap (name k)))
  (valAt [this k default]
    (let [key (name k)]
      (if (.containsKey hmap key)
        (.get hmap (name key))
        default)))
  (seq [this]
    (map (fn [k] [k (.get hmap k)])
         (.keySet hmap))))

(defprotocol MapLike
  (like-map [this]))

(extend-protocol MapLike
  Bundle
  (like-map [b]
    (MapLikeBundle. b))

  Intent
  (like-map [i]
    (if-let [bundle (.getExtras i)]
      (MapLikeBundle. bundle)
      {}))

  SharedPreferences
  (like-map [sp]
    (MapLikeHashMap. (.getAll sp)))

  nil
  (like-map [_] {}))

(ns neko.data.shared-prefs
  (:require [clojure.data :as data])
  (:import [android.content Context SharedPreferences SharedPreferences$Editor]
           neko.App))

(def ^:private sp-access-modes {:private Context/MODE_PRIVATE
                                :world-readable Context/MODE_WORLD_READABLE
                                :world-writeable Context/MODE_WORLD_WRITEABLE})

(defn get-shared-preferences
  ([name mode]
   (get-shared-preferences App/instance name mode))
  ([^Context context, name mode]
   {:pre [(or (number? mode) (contains? sp-access-modes mode))]}
   (let [mode (if (number? mode)
                mode (sp-access-modes mode))]
     (.getSharedPreferences context name mode))))

(defn ^SharedPreferences$Editor put
  [^SharedPreferences$Editor sp-editor, key value]
  (let [key (name key)]
    (condp #(= (type %2) %1) value
      java.lang.Boolean (.putBoolean sp-editor key value)
      java.lang.Float  (.putFloat sp-editor key value)
      java.lang.Double (.putFloat sp-editor key (float value))
      java.lang.Integer (.putInt sp-editor key value)
      java.lang.Long    (.putLong sp-editor key value)
      java.lang.String (.putString sp-editor key value)
      ;; else
      (throw (RuntimeException. (str "SharedPreferences doesn't support type: "
                                     (type value)))))))

(defn bind-atom-to-prefs
  [atom prefs-file-name]
  (let [^SharedPreferences sp (get-shared-preferences prefs-file-name :private)]
    (reset! atom (reduce (fn [m [key val]] (assoc m (keyword key) val))
                         {} (.getAll sp)))
    (add-watch atom ::sp-wrapper
               (fn [_ _ old new]
                 (let [^SharedPreferences$Editor editor (.edit sp)
                       [removed added] (data/diff old new)]
                   (doseq [[key _] removed]
                     (.remove editor (name key)))
                   (doseq [[key val] added]
                     (try (put editor key val) (catch RuntimeException ex _)))
                   (.commit editor))))))

(defmacro defpreferences
  [atom-name prefs-file-name]
  `(do (def ~atom-name (atom {}))
       (when App/instance
         (bind-atom-to-prefs ~atom-name ~prefs-file-name))))

(ns neko.data.sqlite
  (:refer-clojure :exclude [update])
  (:require [clojure.string :as string])
  (:import [android.database.sqlite SQLiteDatabase]
           [neko.data.sqlite SQLiteHelper TaggedCursor]
           [android.database Cursor CursorIndexOutOfBoundsException]
           [android.content ContentValues Context]
           [clojure.lang Keyword PersistentVector]
           neko.App))

(def ^:private supported-types
  {"integer" Integer
   "long" Long
   "text" String
   "boolean" Boolean
   "double" Double
   "blob" Byte})

(defn make-schema
  [& {:as schema}]
  (assert (string? (:name schema)) ":name should be a String.")
  (assert (number? (:version schema)) ":version should be a number.")
  (assert (map? (:tables schema)) ":tables should be a map.")
  (assoc schema
    :tables
    (into
     {} (for [[table-name params] (:tables schema)]
          (do
            (assert (keyword? table-name)
                    (str "Table name should be a keyword: " table-name))
            (assert (map? params)
                    (str "Table parameters should be a map: " table-name))
            (assert (map? (:columns params))
                    (str "Table parameters should contain columns map: " table-name))
            [table-name
             (assoc params
               :columns
               (into
                {} (for [[column-name col-params] (:columns params)]
                     (do
                       (assert (keyword? column-name)
                               (str "Column name should be a keyword: " column-name))
                       (assert (or (map? col-params) (class? Integer))
                               (str "Column type should be a map or a string:"
                                    column-name))
                       (let [col-type (if (string? col-params)
                                        col-params
                                        (:sql-type col-params))
                             java-type (-> (re-matches #"(\w+).*" col-type)
                                           second supported-types)
                             col-params {:type java-type
                                         :sql-type col-type}]
                         (assert java-type
                                 (str "Type is not supported: " (:sql-type col-params)))
                         [column-name col-params])))))])))))

(defn- db-create-query
  [schema table-name]
  (->> (get-in schema [:tables table-name :columns])
       (map (fn [[col params]]
              (str (name col) " " (:sql-type params))))
       (interpose ", ")
       string/join
       (format "create table %s (%s);" (name table-name))))

(defn ^SQLiteHelper create-helper
  ([schema]
   (create-helper App/instance schema))
  ([^Context context, {:keys [name version tables] :as schema}]
   (SQLiteHelper. (.getApplicationContext context) name version schema
                  (for [table (keys tables)]
                    (db-create-query schema table))
                  (for [^Keyword table (keys tables)]
                    (str "drop table if exists " (.getName table))))))

(deftype TaggedDatabase [^SQLiteDatabase db, schema])

(defn get-database
  [^SQLiteHelper helper, access-mode]
  {:pre [(#{:read :write} access-mode)]}
  (TaggedDatabase. (case access-mode
                     :read (.getReadableDatabase helper)
                     :write (.getWritableDatabase helper))
                   (.schema helper)))

(defn- map-to-content
  [^TaggedDatabase tagged-db table data-map]
  (let [^ContentValues cv (ContentValues.)]
    (doseq [[col {type :type}] (get-in (.schema tagged-db)
                                       [:tables table :columns])
            :when (contains? data-map col)]
      (let [value (get data-map col)]
        (condp = type
          Integer (.put cv (name col) ^Integer (int value))
          Long (.put cv (name col) ^Long value)
          Double (.put cv (name col) ^Double value)
          String (.put cv (name col) ^String value)
          Boolean (.put cv (name col) ^Boolean value)
          Byte (.put cv (name col) ^bytes value))))
    cv))

(defn- get-value-from-cursor
  [^Cursor cur i type]
  (condp = type
    Boolean (= (.getInt cur i) 1)
    Integer (.getInt cur i)
    Long (.getLong cur i)
    String (.getString cur i)
    Double (.getDouble cur i)
    Byte (.getBlob cur i)))

(defn- qualified-name
  [^Keyword kw]
  (.toString (if (.getNamespace (.sym kw))
               (str (.getNamespace (.sym kw)) "." (.getName (.sym kw)))
               (.getName (.sym kw)))))

(defn- keyval-to-sql
  [k v]
  (let [qk (qualified-name k)]
    (condp #(= % (type %2)) v
      PersistentVector (let [[op & values] v]
                         (->> values
                              (map (partial keyval-to-sql k))
                              (interpose (str " " (name op) " "))
                              string/join))
      String (format "(%s = '%s')" qk v)
      Boolean (format "(%s = %s)" qk (if v 1 0))
      Keyword (format "(%s = %s)" qk (qualified-name v))
      nil (format "(%s is NULL)" qk)
      (format "(%s = %s)" qk v))))

(defn- where-clause
  [where]
  (if (string? where)
    where
    (->> where
         (map (partial apply keyval-to-sql))
         (interpose " AND ")
         string/join)))

(defn construct-sql-query [select from where]
  (str "select " (string/join (interpose ", " (map qualified-name select)))
       " from " (cond (string? from) from
                      (sequential? from)
                      (string/join (interpose ", " (map name from)))
                      :else (name from))
       (let [wc (where-clause where)]
         (if-not (empty? wc)
           (str " where " wc) ))))

(defn query
  ([^TaggedDatabase tagged-db, from where]
   {:pre [(keyword? from)]}
   (let [columns (->> (get-in (.schema tagged-db) [:tables from :columns])
                      keys)]
     (query tagged-db columns from where)))
  ([^TaggedDatabase tagged-db, column-names from where]
   (let [tables (:tables (.schema tagged-db))
         columns (if (keyword? from)
                   (let [table-cls (:columns (get tables from))]
                     (mapv (fn [cl-name]
                             [cl-name (:type (get table-cls cl-name))])
                           column-names))
                   (mapv (fn [^Keyword kw]
                           (let [cl-name (keyword (.getName kw))
                                 cl (-> (get tables (keyword (.getNamespace kw)))
                                        :columns
                                        (get cl-name))]
                             [kw (:type cl)]))
                         column-names))]
     (TaggedCursor. (.rawQuery ^SQLiteDatabase (.db tagged-db)
                               (construct-sql-query column-names from where) nil)
                    columns))))
(def db-query query)

(defn entity-from-cursor
  [^TaggedCursor cursor]
  (reduce-kv
   (fn [data i [column-name type]]
     (assoc data column-name
            (get-value-from-cursor cursor i type)))
   {} (vec (.columns cursor))))

(defn seq-cursor
  [^TaggedCursor cursor]
  (.moveToFirst cursor)
  (let [seq-fn (fn seq-fn []
                 (lazy-seq
                  (if (.isAfterLast cursor)
                    (.close cursor)
                    (let [v (entity-from-cursor cursor)]
                      (.moveToNext cursor)
                      (cons v (seq-fn))))))]
    (seq-fn)))

(defn query-seq
  {:forms '([tagged-db table-name where] [tagged-db columns from where])}
  [& args]
  (seq-cursor (apply query args)))
(def db-query-seq query-seq)

(defn query-scalar
  [^TaggedDatabase tagged-db column table-name where]
  (let [[aggregator column] (if (vector? column)
                              column [nil column])
        type (get-in (.schema tagged-db)
                     [:tables table-name :columns column :type])
        where-cl (where-clause where)
        query (format "select %s from %s %s"
                      (if aggregator
                        (str aggregator "(" (name column) ")")
                        (name column))
                      (name table-name)
                      (if (seq where-cl)
                        (str "where " where-cl) ""))]
    (with-open [cursor (.rawQuery ^SQLiteDatabase (.db tagged-db) query nil)]
      (try (.moveToFirst ^Cursor cursor)
           (get-value-from-cursor cursor 0 type)
           (catch CursorIndexOutOfBoundsException e nil)))))

(defn update
  [^TaggedDatabase tagged-db table-name set where]
  (.update ^SQLiteDatabase (.db tagged-db) (name table-name)
           (map-to-content tagged-db table-name set)
           (where-clause where) nil))
(def db-update update)

(defn insert
  [^TaggedDatabase tagged-db table-name data-map]
  (.insert ^SQLiteDatabase (.db tagged-db) (name table-name) nil
           (map-to-content tagged-db table-name data-map)))
(def db-insert insert)

(defn transact*
  [^TaggedDatabase tagged-db, transact-fn]
  (let [^SQLiteDatabase db (.db tagged-db)]
    (try (.beginTransaction db)
         (transact-fn)
         (.setTransactionSuccessful db)
         (finally (.endTransaction db)))))

(defmacro transact
  [tagged-db & body]
  `(transact* ~tagged-db (fn [] ~@body)))

(ns neko.debug
  (:require [neko log notify])
  (:import android.app.Activity
           android.view.WindowManager$LayoutParams
           java.util.WeakHashMap))

(def ^WeakHashMap all-activities
  (WeakHashMap.))

(defmacro ^Activity *a
  ([]
   `(get all-activities '~(.name *ns*)))
  ([key]
   `(get all-activities ~key)))

(def ^:private ui-exception (atom nil))

(defn handle-exception-from-ui-thread
  [e]
  (reset! ui-exception e)
  (neko.log/e "Exception raised on UI thread." :exception e)
  (neko.notify/toast (str e) :long))

(defn ui-e
  [] @ui-exception)

(defmacro safe-for-ui
  [& body]
  (if (:neko.init/release-build *compiler-options*)
    `(do ~@body)
    `(try ~@body
          (catch Throwable e# (handle-exception-from-ui-thread e#)))))

(defn safe-for-ui*
  [f]
  (fn [] (safe-for-ui (f))))

(defmacro keep-screen-on
  [^Activity activity]
  (if (:neko.init/release-build *compiler-options*)
    nil
    `(.addFlags (.getWindow ~activity)
                WindowManager$LayoutParams/FLAG_KEEP_SCREEN_ON)))

(ns neko.dialog.alert
  (:require [neko.listeners.dialog :as listeners]
            [neko.resource :as res]
            neko.ui
            [neko.ui.mapping :refer [defelement]]
            [neko.ui.traits :refer [deftrait]])
  (:import android.app.AlertDialog$Builder))

(deftrait :positive-button
  {:attributes [:positive-text :positive-callback]}
  [^AlertDialog$Builder builder,
   {:keys [positive-text positive-callback]} _]
  (.setPositiveButton builder (res/get-string (.getContext builder) positive-text)
                      (listeners/on-click-call positive-callback)))

(deftrait :negative-button
  {:attributes [:negative-text :negative-callback]}
  [^AlertDialog$Builder builder,
   {:keys [negative-text negative-callback]} _]
  (.setNegativeButton builder (res/get-string (.getContext builder) negative-text)
                      (listeners/on-click-call negative-callback)))

(deftrait :neutral-button
  {:attributes [:neutral-text :neutral-callback]}
  [^AlertDialog$Builder builder,
   {:keys [neutral-text neutral-callback]} _]
  (.setNegativeButton builder (res/get-string (.getContext builder) neutral-text)
                      (listeners/on-click-call neutral-callback)))

(defelement :alert-dialog-builder
  :classname AlertDialog$Builder
  :inherits nil
  :traits [:positive-button :negative-button :neutral-button])

(defn ^AlertDialog$Builder alert-dialog-builder
  [context options-map]
  (neko.ui/make-ui context [:alert-dialog-builder options-map]))

(ns neko.doc
  (:require [neko.ui.traits :as traits]
            [neko.ui.mapping :as mapping])
  (:use [clojure.string :only [join]]))

(defn get-trait-doc
  [trait]
  (when-let [doc (get-in (meta #'traits/apply-trait)
                            [:trait-doc trait])]
    (str trait " - " doc)))

(defn get-element-doc
  [el-type el-mapping verbose?]
  (let [{:keys [classname attributes values]} el-mapping
        traits (mapping/all-traits el-type)]
   (format "%s - %s\n%s%s%s\n"
           el-type
           (or (and classname (.getName ^Class classname))
               "no matching class")
           (if (empty? traits) ""
               (format "Implements traits: %s\n"
                       (if verbose?
                         (join (for [t traits]
                                 (str "\n" (get-trait-doc t))))
                         (join (map (partial str "\n  ") traits)))))
           (if (empty? attributes) ""
               (format "Default attributes: %s\n"
                       (pr-str attributes)))
           (if (empty? values) ""
               (format "Special values: %s\n"
                       (pr-str values))))))

(defn describe
  ([]
     (let [all-elements (mapping/get-keyword-mapping)]
       (doseq [[el-type parameters] all-elements]
         (print (get-element-doc el-type parameters false)))))
  ([kw]
     (describe kw nil))
  ([kw modifier]
     (let [parameters ((mapping/get-keyword-mapping) kw)
           trait-doc (get-trait-doc kw)]
       (cond
        parameters (print "Elements found:\n"
                          (get-element-doc kw parameters (= modifier :verbose)))
        trait-doc (print "\nTraits found:\n" trait-doc)
        :else (print (str "No elements or traits were found for " kw))))))

(ns neko.find-view
  (:require [neko.activity :refer [get-decor-view]])
  (:import android.view.View
           android.app.Activity))

(defn- nil-or-view?
  [x]
  (or (nil? x)
      (instance? android.view.View x)))

(defprotocol ViewFinder
  (find-view [container id]))

(extend-protocol ViewFinder
  View
  (find-view [^View view, id]
    {:post [(nil-or-view? %)]}
    (get (.getTag view) id))

  Activity
  (find-view [^Activity activity, id]
    {:post [(nil-or-view? %)]}
    (find-view (get-decor-view activity) id)))

(defn find-views
  [container & ids]
  (map (partial find-view container) ids))

(ns neko.intent
  (:require [neko.-utils :refer [app-package-name]])
  (:import [android.content Context Intent]
           android.os.Bundle))

(defn put-extras
  [^Intent intent, extras-map]
  (doseq [[key value] extras-map
          :let [key (name key)]]
    (case (type value)
      ;; Non-reflection calls for the most frequent cases.
      Long (.putExtra intent key ^long value)
      Double (.putExtra intent key ^double value)
      String (.putExtra intent key ^String value)
      Boolean (.putExtra intent key ^boolean value)
      Bundle (.putExtra intent key ^Bundle value)
      ;; Else fall back to reflection
      (.putExtra intent key value)))
  intent)

(defn intent
  ([^String action, extras]
   (put-extras (doto (Intent. action)) extras))
  ([^Context context, classname extras]
   (let [^Class class (if (symbol? classname)
                        (resolve
                         (if (.startsWith ^String (str classname) ".")
                           (symbol (str (app-package-name) classname))
                           classname))
                        classname)]
     (put-extras (doto (Intent. context class)) extras))))

(ns neko.listeners.adapter-view
  {:author "Daniel Solano Gómez"}
  (:require [neko.debug :refer [safe-for-ui]]))

(defn on-item-click-call
  ^android.widget.AdapterView$OnItemClickListener
  [handler-fn]
  {:pre  [(fn? handler-fn)]
   :post [(instance? android.widget.AdapterView$OnItemClickListener %)]}
  (reify android.widget.AdapterView$OnItemClickListener
    (onItemClick [this parent view position id]
      (safe-for-ui (handler-fn parent view position id)))))

(defmacro on-item-click
  [& body]
  `(on-item-click-call (fn [~'parent ~'view ~'position ~'id] ~@body)))

(defn on-item-long-click-call
  ^android.widget.AdapterView$OnItemLongClickListener
  [handler-fn]
  {:pre  [(fn? handler-fn)]
   :post [(instance? android.widget.AdapterView$OnItemLongClickListener %)]}
  (reify android.widget.AdapterView$OnItemLongClickListener
    (onItemLongClick [this parent view position id]
      (safe-for-ui (boolean (handler-fn parent view position id))))))

(defmacro on-item-long-click
  [& body]
  `(on-item-long-click-call (fn [~'parent ~'view ~'position ~'id] ~@body)))

(defn on-item-selected-call
  ([item-fn]
   {:pre  [(fn? item-fn)]
    :post [(instance? android.widget.AdapterView$OnItemSelectedListener %)]}
   (on-item-selected-call item-fn nil))
  (^android.widget.AdapterView$OnItemSelectedListener
   [item-fn nothing-fn]
   {:pre  [(fn? item-fn)
           (or (nil? nothing-fn)
               (fn? nothing-fn))]
    :post [(instance? android.widget.AdapterView$OnItemSelectedListener %)]}
   (reify android.widget.AdapterView$OnItemSelectedListener
     (onItemSelected [this parent view position id]
       (safe-for-ui (item-fn parent view position id)))
     (onNothingSelected [this parent]
       (safe-for-ui (when nothing-fn
                      (nothing-fn parent)))))))

(defmacro on-item-selected
  [& body]
  `(let [handler-fn# (fn [~'type ~'parent ~'view ~'position ~'id]
                       ~@body)]
     (on-item-selected-call
       (fn ~'item-handler [parent# view# position# id#]
         (handler-fn# :item parent# view# position# id#))
       (fn ~'nothing-handler [parent#]
         (handler-fn# :nothing parent# nil nil nil)))))

(ns neko.listeners.dialog
  {:author "Daniel Solano Gómez"}
  (:require [neko.debug :refer [safe-for-ui]])
  (:import android.content.DialogInterface))

(defn on-cancel-call
  ^android.content.DialogInterface$OnCancelListener
  [handler-fn]
  (reify android.content.DialogInterface$OnCancelListener
    (onCancel [this dialog]
      (safe-for-ui (handler-fn dialog)))))

(defmacro on-cancel
  [& body]
  `(on-cancel-call (fn [~'dialog] ~@body)))

(defn on-click-call
  ^android.content.DialogInterface$OnClickListener
  [handler-fn]
  (reify android.content.DialogInterface$OnClickListener
    (onClick [this dialog which]
      (let [which (condp = which
                    DialogInterface/BUTTON_NEGATIVE :negative
                    DialogInterface/BUTTON_NEUTRAL  :neutral
                    DialogInterface/BUTTON_POSITIVE :positive
                    which)]
        (safe-for-ui (handler-fn dialog which))))))

(defmacro on-click
  [& body]
  `(on-click-call (fn [~'dialog ~'which] ~@body)))

(defn on-dismiss-call
  ^android.content.DialogInterface$OnDismissListener
  [handler-fn]
  (reify android.content.DialogInterface$OnDismissListener
    (onDismiss [this dialog]
      (safe-for-ui (handler-fn dialog)))))

(defmacro on-dismiss
  [& body]
  `(on-dismiss-call (fn [~'dialog] ~@body)))

(defn on-key-call
  ^android.content.DialogInterface$OnKeyListener
  [handler-fn]
  (reify android.content.DialogInterface$OnKeyListener
    (onKey [this dialog key-code event]
      (safe-for-ui (boolean (handler-fn dialog key-code event))))))

(defmacro on-key
  [& body]
  `(on-key-call (fn [~'dialog ~'key-code ~'event] ~@body)))

(defn on-multi-choice-click-call
  ^android.content.DialogInterface$OnMultiChoiceClickListener
  [handler-fn]
  (reify android.content.DialogInterface$OnMultiChoiceClickListener
    (onClick [this dialog which checked?]
      (safe-for-ui (handler-fn dialog which checked?)))))

(defmacro on-multi-choice-click
  [& body]
  `(on-multi-choice-click-call (fn [~'dialog ~'which ~'checked?] ~@body)))

(ns neko.listeners.search-view
  (:require [neko.debug :refer [safe-for-ui]])
  (:use [neko.-utils :only [call-if-nnil]])
  (:import android.widget.SearchView))

(defn on-query-text-call
  ^android.widget.SearchView$OnQueryTextListener
  [change-fn submit-fn]
  (reify android.widget.SearchView$OnQueryTextListener
    (onQueryTextChange [this query]
      (safe-for-ui (call-if-nnil change-fn query)))
    (onQueryTextSubmit [this query]
      (safe-for-ui (call-if-nnil submit-fn query)))))

(ns neko.listeners.text-view
  {:author "Daniel Solano Gómez"}
  (:require [neko.debug :refer [safe-for-ui]]))

(defn on-editor-action-call
  [handler-fn]
  ^android.widget.TextView$OnEditorActionListener
  {:pre  [(fn? handler-fn)]
   :post [(instance? android.widget.TextView$OnEditorActionListener %)]}
  (reify android.widget.TextView$OnEditorActionListener
    (onEditorAction [this view action-id key-event]
      (safe-for-ui (boolean (handler-fn view action-id key-event))))))

(defmacro on-editor-action
  [& body]
  `(on-editor-action-call (fn [~'view ~'action-id ~'key-event] ~@body)))

(ns neko.listeners.view
  {:author "Daniel Solano Gómez"}
  (:require [neko.debug :refer [safe-for-ui]]))

(defn on-click-call
  ^android.view.View$OnClickListener
  [handler-fn]
  (reify android.view.View$OnClickListener
    (onClick [this view]
      (safe-for-ui (handler-fn view)))))

(defmacro on-click
  [& body]
  `(on-click-call (fn [~'view] ~@body)))

(defn on-create-context-menu-call
  ^android.view.View$OnCreateContextMenuListener
  [handler-fn]
  (reify android.view.View$OnCreateContextMenuListener
    (onCreateContextMenu [this menu view info]
      (safe-for-ui (handler-fn menu view info)))))

(defmacro on-create-context-menu
  [& body]
  `(on-create-context-menu-call (fn [~'menu ~'view ~'info] ~@body)))

(comment -- Introduced in SDK version 11 (Honeycomb)
(defn on-drag-call
  ^android.view.View$OnDragListener
  [handler-fn]
  (reify android.view.View$OnDragListener
    (onDrag [this view event]
      (safe-for-ui (handler-fn view event)))))
(defmacro on-drag
  "Takes a body of expressions and yields a View.OnDragListener object that
  will invoke the body.  The body takes the following two implicit arguments:
  view:  the view that received the drag event
  event: the DragEvent object for the drag event"
  [& body]
  `(on-drag-call (fn [~'view ~'event] ~@body))))

(defn on-focus-change-call
  ^android.view.View$OnFocusChangeListener
  [handler-fn]
  (reify android.view.View$OnFocusChangeListener
    (onFocusChange [this view focused?]
      (safe-for-ui (handler-fn view focused?)))))

(defmacro on-focus-change
  [& body]
  `(on-focus-change-call (fn [~'view ~'focused?] ~@body)))

(defn on-key-call
  ^android.view.View$OnKeyListener
  [handler-fn]
  (reify android.view.View$OnKeyListener
    (onKey [this view key-code event]
      (safe-for-ui (boolean (handler-fn view key-code event))))))

(defmacro on-key
  [& body]
  `(on-key-call (fn [~'view ~'key-code ~'event] ~@body)))

(comment -- as of API level 11
(defn on-layout-change-call
  ^android.view.View$OnLayoutChangeListener
  [handler-fn]
  (reify android.view.View$OnLayoutChangeListener
    (onLayoutChange [this view left top right bottom
                     old-left old-top old-right old-bottom]
      (safe-for-ui (handler-fn view left top right bottom
                               old-left olt-top old-right old-bottom)))))
(defmacro on-layout-change
  "Takes a body of expressions and yields a View.OnLayoutChangeListener
  object that will invoke the body.  The body takes the following implicit
  arguments:
  view:       the view whose state has changed
  left:       the new value of the view's left property
  top:        the new value of the view's top property
  right:      the new value of the view's right property
  bottom:     the new value of the view's bottom property
  old-left:   the previous value of the view's left property
  old-top:    the previous value of the view's top property
  old-right:  the previous value of the view's right property
  old-bottom: the previous value of the view's bottom property"
  [& body]
  `(on-key-call (fn [~'view ~'left ~'top ~'right ~'bottom
                 ~'old-left ~'old-top ~'old-right ~'old-bottom] ~@body))))

(defn on-long-click-call
  ^android.view.View$OnLongClickListener
  [handler-fn]
  (reify android.view.View$OnLongClickListener
    (onLongClick [this view]
      (safe-for-ui (boolean (handler-fn view))))))

(defmacro on-long-click
  [& body]
  `(on-long-click-call (fn [~'view] ~@body)))

(comment -- incomplete -- also for API level 11 (Honeycomb)
(defn on-system-ui-visibility-change-call
  ^android.view.View$OnSystemUiVisibilityChangeListener
  [handler-fn]
  (reify android.view.View$OnSystemUiVisibilityChangeListener
    (onLongClick [this view]
      (safe-for-ui (handler-fn view)))))
(defmacro on-system-ui-visibility-change
  [& body]
  `(on-system-ui-visibility-change-call (fn [~'visibility] ~@body))))

(defn on-touch-call
  ^android.view.View$OnTouchListener
  [handler-fn]
  (reify android.view.View$OnTouchListener
    (onTouch [this view event]
      (safe-for-ui (boolean (handler-fn view event))))))

(defmacro on-touch
  [& body]
  `(on-touch-call (fn [~'view ~'event] ~@body)))

(ns neko.log
  {:author "Adam Clements"}
  (:import android.util.Log))

(defn- logger [logfn priority-kw args]
  (when-not ((set (:neko.init/ignore-log-priority *compiler-options*))
             priority-kw)
    (let [[strings kwargs] (split-with (complement #{:exception :tag}) args)
          {:keys [exception tag]} (if (odd? (count kwargs))
                                    (butlast kwargs)
                                    kwargs)
          tag (or tag (str *ns*))
          ex-form (if exception [exception] ())]
      `(binding [*print-readably* nil]
         (. Log ~logfn ~tag (pr-str ~@strings) ~@ex-form)))))

(defmacro e
  [& args] (logger 'e :error args))

(defmacro d
  [& args] (logger 'd :debug args))

(defmacro i
  [& args] (logger 'i :info args))

(defmacro v
  [& args] (logger 'v :verbose args))

(defmacro w
  [& args] (logger 'w :warn args))

(ns neko.notify
  (:require [neko.-utils :refer [int-id]])
  (:import [android.app Notification NotificationManager PendingIntent]
           [android.content Context Intent]
           android.widget.Toast
           neko.App))

(defn toast
  ([message]
   (toast App/instance message :long))
  ([message length]
   (toast App/instance message length))
  ([^Context context, ^String message, length]
   {:pre [(or (= length :short) (= length :long))]}
   (.show
    ^Toast (Toast/makeText context message ^int (case length
                                                  :short Toast/LENGTH_SHORT
                                                  :long Toast/LENGTH_LONG)))))

(defn- ^NotificationManager notification-manager
  ([^Context context]
   (.getSystemService context Context/NOTIFICATION_SERVICE)))

(defn construct-pending-intent
  ([context [action-type, ^String action]]
     (let [^Intent intent (Intent. action)]
       (case action-type
         :activity (PendingIntent/getActivity context 0 intent 0)
         :broadcast (PendingIntent/getBroadcast context 0 intent 0)
         :service (PendingIntent/getService context 0 intent 0)))))

(defn notification
  ([options]
   (notification App/instance options))
  ([context {:keys [icon ticker-text when content-title content-text action]
             :or {icon android.R$drawable/ic_dialog_info
                  when (System/currentTimeMillis)}}]
   (let [notification (Notification. icon ticker-text when)]
     (.setLatestEventInfo notification context content-title content-text
                          (construct-pending-intent context action))
     notification)))

(defn fire
  ([id notification]
   (fire App/instance id notification))
  ([context id notification]
   (let [id (if (keyword? id)
              (int-id id)
              id)]
     (.notify (notification-manager context) id notification))))

(defn cancel
  ([id]
   (cancel App/instance id))
  ([context id]
   (.cancel (notification-manager context) (if (keyword? id)
                                             (int-id id)
                                             id))))

(ns neko.resource
  (:require [neko.-utils :refer [app-package-name]])
  (:import android.content.Context
           android.graphics.drawable.Drawable
           neko.App))

(defmacro import-all
  []
  `(do ~@(map (fn [res-type]
                `(try (import '~(-> (app-package-name)
                                    (str ".R$" res-type)
                                    symbol))
                      (catch ClassNotFoundException _# nil)))
              '[anim drawable color layout menu string array plurals style id
                dimen])))

(import-all)

(defn get-string
  {:forms '([res-id & format-args?] [context res-id & format-args?])}
  [& args]
  (let [[^Context context args] (if (instance? Context (first args))
                                  [(first args) (rest args)]
                                  [App/instance args])
        [res-id & format-args] args]
    (cond (not (number? res-id)) res-id
          format-args      (.getString context res-id (to-array format-args))
          :else            (.getString context res-id))))

(defn get-drawable
  ([res-id]
   (get-drawable App/instance res-id))
  ([^Context context, res-id]
   (if-not (number? res-id)
     res-id
     (.getDrawable (.getResources context) res-id))))

(ns neko.threading
  (:use [neko.debug :only [safe-for-ui]])
  (:import android.view.View
           android.os.Looper
           android.os.Handler))

(defn on-ui-thread?
  []
  (identical? (Thread/currentThread)
              (.getThread ^Looper (Looper/getMainLooper))))

(defmacro on-ui
  [& body]
  `(if (on-ui-thread?)
     (safe-for-ui ~@body)
     (.post (Handler. (Looper/getMainLooper)) (fn [] (safe-for-ui ~@body)))))

(defn on-ui*
  [f]
  (on-ui (f)))

(defmacro post
  [view & body]
  `(.post ^View ~view (fn [] ~@body)))

(defmacro post-delayed
  [view millis & body]
  `(.postDelayed ^View ~view ~millis (fn [] ~@body)))

(ns neko.tools.repl
  (:require [neko.log :as log])
  (:import android.content.Context
           android.util.Log
           java.io.FileNotFoundException
           java.util.concurrent.atomic.AtomicLong
           java.util.concurrent.ThreadFactory))

(def cider-middleware
  '[cider.nrepl.middleware.apropos/wrap-apropos
    cider.nrepl.middleware.classpath/wrap-classpath
    cider.nrepl.middleware.complete/wrap-complete
    cider.nrepl.middleware.info/wrap-info
    cider.nrepl.middleware.inspect/wrap-inspect
    cider.nrepl.middleware.macroexpand/wrap-macroexpand
    cider.nrepl.middleware.ns/wrap-ns
    cider.nrepl.middleware.resource/wrap-resource
    cider.nrepl.middleware.stacktrace/wrap-stacktrace
    cider.nrepl.middleware.test/wrap-test
    cider.nrepl.middleware.trace/wrap-trace
    cider.nrepl.middleware.undef/wrap-undef])

(defn cider-available?
  []
  (try (require 'cider.nrepl.version)
       true
       (catch FileNotFoundException e false)))

(defn android-thread-factory
  []
  (let [counter (AtomicLong. 0)]
    (reify ThreadFactory
      (newThread [_ runnable]
        (doto (Thread. (.getThreadGroup (Thread/currentThread))
                       runnable
                       (format "nREPL-worker-%s" (.getAndIncrement counter))
                       1048576) ;; Hardcoded stack size of 1Mb
          (.setDaemon true))))))

(defn- patch-unsupported-dependencies
  []
  (let [curr-ns (ns-name *ns*)]
    (ns dynapath.util)
    (defn add-classpath! [& _])
    (defn addable-classpath [& _])
    (in-ns curr-ns)))

(defn enable-compliment-sources
  []
  (try (require 'neko.compliment.ui-widgets-and-attributes)
       ((resolve 'neko.compliment.ui-widgets-and-attributes/init-source))
       (catch Exception ex nil)))

(defn start-repl
  [middleware & repl-args]
  (binding [*ns* (create-ns 'user)]
    (refer-clojure)
    (patch-unsupported-dependencies)
    (use 'clojure.tools.nrepl.server)
    (require '[clojure.tools.nrepl.middleware.interruptible-eval :as ie])
    (with-redefs-fn {(resolve 'ie/configure-thread-factory)
                     android-thread-factory}
      #(apply (resolve 'start-server)
              :handler (apply (resolve 'default-handler)
                              (map (fn [sym]
                                     (require (symbol (namespace sym)))
                                     (resolve sym))
                                   middleware))
              repl-args))))

(defmacro start-nrepl-server
  [args]
  (when (or (not (:neko.init/release-build *compiler-options*))
            (:neko.init/start-nrepl-server *compiler-options*))
    (let [build-port (:neko.init/nrepl-port *compiler-options*)
          mware (when (cider-available?)
                  (list `quote
                        (or (:neko.init/nrepl-middleware *compiler-options*)
                            cider-middleware)))]
      `(let [port# (or ~(:port args) ~build-port 9999)
             args# (assoc ~args :port port#)]
         (try (apply start-repl ~mware (mapcat identity args#))
              (neko.log/i "Nrepl started at port" port#)
              (catch Exception ex#
                (neko.log/e "Failed to start nREPL" :exception ex#)))))))

(defn init
  [& {:as args}]
  (start-nrepl-server args))

(ns neko.ui
  (:require [neko.ui.mapping :as kw]
            [neko.ui.traits :refer [apply-trait]]
            [neko.-utils :refer [keyword->setter reflect-setter
                                 reflect-constructor]])
  (:import android.content.res.Configuration
           neko.App))

(defn apply-default-setters-from-attributes
  [widget-kw widget attributes]
  (doseq [[attribute value] attributes]
    (let [real-value (kw/value widget-kw value attribute)]
      (.invoke (reflect-setter (type widget)
                               (keyword->setter attribute)
                               (type real-value))
               widget (into-array (vector real-value))))))

(defn apply-attributes
  [widget-kw widget attributes options]
  (loop [[trait & rest] (kw/all-traits widget-kw),
         attrs attributes, new-opts options]
    (if trait
      (let [[attributes-fn options-fn]
            (apply-trait trait widget attrs options)]
        (recur rest (attributes-fn attrs) (options-fn new-opts)))
      (do
        (apply-default-setters-from-attributes widget-kw widget attrs)
        new-opts))))

(defn construct-element
  ([kw context constructor-args]
     (let [element-class (kw/classname kw)]
       (.newInstance (reflect-constructor element-class
                                          (cons android.content.Context
                                                (map type constructor-args)))
                     (to-array (cons context constructor-args))))))

(defn make-ui-element
  [context tree options]
  (if (sequential? tree)
    (let [[widget-kw attributes & inside-elements] tree
          _ (assert (and (keyword? widget-kw) (map? attributes)))
          attributes (merge (kw/default-attributes widget-kw) attributes)
          wdg (if-let [constr (:custom-constructor attributes)]
                (apply constr context (:constructor-args attributes))
                (construct-element widget-kw context
                                   (:constructor-args attributes)))
          new-opts (apply-attributes
                    widget-kw wdg
                    ;; Remove :custom-constructor and
                    ;; :constructor-args since they are not real
                    ;; attributes.
                    (dissoc attributes :constructor-args :custom-constructor)
                    options)]
      (doseq [element inside-elements :when element]
        (.addView ^android.view.ViewGroup wdg
                  (make-ui-element context element new-opts)))
      wdg)
    tree))

(defn make-ui
  [activity tree]
  (make-ui-element activity tree {}))

(defn config
  [widget & {:as attributes}]
  (apply-attributes (kw/keyword-by-classname (type widget))
                    widget attributes {}))

(defn inflate-layout
  [activity id]
  {:pre [(integer? id)]
   :post [(instance? android.view.View %)]}
  (.. android.view.LayoutInflater
      (from activity)
      (inflate ^Integer id nil)))

(defn get-screen-orientation
  ([]
   (get-screen-orientation App/instance))
  ([context]
   (condp = (.. context (getResources) (getConfiguration) orientation)
     Configuration/ORIENTATION_PORTRAIT :portrait
     Configuration/ORIENTATION_LANDSCAPE :landscape
     Configuration/ORIENTATION_SQUARE :square
     :undefined)))

(ns neko.ui.adapters
  (:require [neko.debug :refer [safe-for-ui]]
            [neko.data.sqlite :refer [entity-from-cursor]]
            [neko.threading :refer [on-ui]]
            [neko.ui :refer [make-ui-element]])
  (:import android.view.View
           neko.data.sqlite.TaggedCursor
           [neko.ui.adapters InterchangeableListAdapter TaggedCursorAdapter]))

(defn ref-adapter
  ([create-view-fn update-view-fn ref-type]
   (ref-adapter create-view-fn update-view-fn ref-type identity))
  ([create-view-fn update-view-fn ref-type access-fn]
   {:pre [(fn? create-view-fn) (fn? update-view-fn)
          (instance? clojure.lang.IFn access-fn)
          (instance? clojure.lang.IDeref ref-type)]}
   (let [create-fn (fn [context]
                     (or (safe-for-ui
                          (let [view (create-view-fn context)]
                            (if (instance? View view)
                              view
                              (make-ui-element
                               context view
                               {:container-type :abs-listview-layout}))))
                         (android.view.View. context)))
         adapter (InterchangeableListAdapter.
                  create-fn
                  (fn [pos view parent data]
                    (safe-for-ui (update-view-fn pos view parent data)))
                  (access-fn @ref-type))]
     (add-watch ref-type ::adapter-watch
                (fn [_ __ ___ new-state]
                  (on-ui (.setData adapter (access-fn new-state)))))
     adapter)))

(defn cursor-adapter
  [context create-view-fn update-view-fn cursor-or-cursor-fn]
  {:pre [(fn? create-view-fn) (fn? update-view-fn)
         (or (fn? cursor-or-cursor-fn)
             (instance? TaggedCursor cursor-or-cursor-fn))]}
  (let [create-fn (fn [context]
                    (or (safe-for-ui
                         (let [view (create-view-fn)]
                           (if (instance? View view)
                             view
                             (make-ui-element
                              context view
                              {:container-type :abs-listview-layout}))))
                        (android.view.View. context)))]
    (TaggedCursorAdapter.
     context create-fn
     (fn [view cursor data]
       (safe-for-ui (update-view-fn view cursor data)))
     cursor-or-cursor-fn)))

(defn update-cursor
  ([^TaggedCursorAdapter cursor-adapter]
   (.updateCursor cursor-adapter))
  ([^TaggedCursorAdapter cursor-adapter new-cursor]
   (.updateCursor cursor-adapter new-cursor)))

(ns neko.ui.listview
  (:import android.util.SparseBooleanArray
           android.widget.ListView))

(defn get-checked
  ([^ListView lv]
     (let [^SparseBooleanArray bool-array (.getCheckedItemPositions lv)
           count (.getCount lv)]
       (loop [i 0, result []]
         (if (= i count)
           result
           (if (.get bool-array i)
             (recur (inc i) (conj result i))
             (recur (inc i) result))))))
  ([^ListView lv, items]
     (let [^SparseBooleanArray bool-array (.getCheckedItemPositions lv)
           count (.getCount lv)]
       (loop [i 0, [curr & rest] items, result []]
         (if (= i count)
           result
           (if (.get bool-array i)
             (recur (inc i) rest (conj result curr))
             (recur (inc i) rest result)))))))

(defn set-checked!
  [^ListView lv, checked-ids]
  (doseq [i checked-ids]
    (.setItemChecked lv i true)))

(ns neko.ui.mapping
  (:require [clojure.string :as string])
  (:use [neko.-utils :only [keyword->static-field reflect-field]])
  (:import [android.widget LinearLayout Button EditText ListView SearchView
            ImageView ImageView$ScaleType RelativeLayout ScrollView FrameLayout
            Gallery]
           android.app.ProgressDialog
           android.view.inputmethod.EditorInfo
           [android.view View ViewGroup$LayoutParams Gravity]))

(def ^{:private true} keyword-mapping
  (atom
   ;; UI widgets
   {:view {:classname android.view.View
           :traits [:def :id :padding :on-click :on-long-click :on-touch
                    :on-create-context-menu :on-key
                    :default-layout-params :linear-layout-params
                    :relative-layout-params :listview-layout-params
                    :frame-layout-params :gallery-layout-params]
           :value-namespaces
           {:gravity android.view.Gravity
            :visibility android.view.View}}
    :view-group {:inherits :view
                 :traits [:container :id-holder]}
    :button {:classname android.widget.Button
             :inherits :text-view
             :attributes {:text "Default button"}}
    :linear-layout {:classname android.widget.LinearLayout
                    :inherits :view-group}
    :relative-layout {:classname android.widget.RelativeLayout
                      :inherits :view-group}
    :frame-layout {:classname android.widget.FrameLayout
                   :inherits :view-group}
    :edit-text {:classname android.widget.EditText
                :inherits :view
                :values {:number      EditorInfo/TYPE_CLASS_NUMBER
                         :datetime    EditorInfo/TYPE_CLASS_DATETIME
                         :text        EditorInfo/TYPE_CLASS_TEXT
                         :phone       EditorInfo/TYPE_CLASS_PHONE
                         :go          EditorInfo/IME_ACTION_GO
                         :done        EditorInfo/IME_ACTION_DONE
                         :unspecified EditorInfo/IME_ACTION_UNSPECIFIED
                         :send        EditorInfo/IME_ACTION_SEND
                         :search      EditorInfo/IME_ACTION_SEARCH
                         :previous    EditorInfo/IME_ACTION_PREVIOUS
                         :next        EditorInfo/IME_ACTION_NEXT}}
    :progress-bar {:classname android.widget.ProgressBar
                   :inherits  :view
                   :value-namespaces {:visibility android.view.View}}
    :progress-bar-large {:inherits  :progress-bar
                         :constructor-args [nil android.R$attr/progressBarStyleLarge]}
    :text-view {:classname android.widget.TextView
                :inherits :view
                :value-namespaces
                {:ellipsize android.text.TextUtils$TruncateAt}
                :traits [:text :text-size :on-editor-action]}
    :list-view {:classname android.widget.ListView
                :inherits :view-group
                :traits [:on-item-click]}
    :search-view {:classname android.widget.SearchView
                  :inherits :view-group
                  :traits [:on-query-text]}
    :image-view {:classname android.widget.ImageView
                 :inherits :view
                 :traits [:image]
                 :value-namespaces
                 {:scale-type android.widget.ImageView$ScaleType}}
    :web-view {:classname android.webkit.WebView
               :inherits :view}
    :scroll-view {:classname android.widget.ScrollView
                  :inherits :view}
    :gallery {:classname android.widget.Gallery
              :inherits :view-group
              :traits [:on-item-click]}
    ;; Other
    :layout-params {:classname ViewGroup$LayoutParams
                    :values {:fill ViewGroup$LayoutParams/FILL_PARENT
                             :wrap ViewGroup$LayoutParams/WRAP_CONTENT}
                    :value-namespaces
                    {:gravity android.view.Gravity}}
    :progress-dialog {:classname android.app.ProgressDialog
                      :values {:horizontal ProgressDialog/STYLE_HORIZONTAL
                               :spinner ProgressDialog/STYLE_SPINNER}}
    }))

(defn get-keyword-mapping
  []
  @keyword-mapping)

(def ^{:private true} reverse-mapping
  (atom
   {android.widget.Button :button
    android.widget.LinearLayout :linear-layout
    android.widget.RelativeLayout :relative-layout
    android.widget.FrameLayout :frame-layout
    android.widget.EditText :edit-text
    android.widget.TextView :text-view
    android.widget.ListView :list-view
    android.widget.ImageView :image-view
    android.webkit.WebView :web-view
    android.widget.ScrollView :scroll-view
    android.widget.Gallery :gallery
    android.app.ProgressDialog :progress-dialog}))

(defn set-classname!
  [kw classname]
  (swap! keyword-mapping assoc-in [kw :classname] classname)
  (swap! reverse-mapping assoc-in classname kw))

(defn classname
  [classname-or-kw]
  (if (keyword? classname-or-kw)
    (or (get-in @keyword-mapping [classname-or-kw :classname])
        (throw (Exception. (str "The class for " classname-or-kw
                                " isn't present in the mapping."))))
    classname-or-kw))

(defn keyword-by-classname
  [classname]
  (@reverse-mapping classname))

(defn add-trait!
  [kw trait-kw]
  (swap! keyword-mapping update-in [kw :traits] conj trait-kw))

(defn all-traits
  [kw]
  (let [own-traits (get-in @keyword-mapping [kw :traits])
        parent (get-in @keyword-mapping [kw :inherits])]
    (concat own-traits (when parent
                         (all-traits parent)))))

(defn set-value!
  [element-kw value-kw value]
  (swap! keyword-mapping assoc-in [element-kw :values value-kw] value))

(defn- recursive-find
  [[element-kw & other :as keys]]
  (if element-kw
    (or (get-in @keyword-mapping keys)
        (recur (cons (get-in @keyword-mapping [element-kw :inherits]) other)))))

(defn value
  [element-kw value & [attribute]]
  (let [mapping @keyword-mapping]
    (if-not (keyword? value)
      (cond
       (integer? value) (int value)
       (float? value) (float value)
       :else value)
      (or (recursive-find (list element-kw :values value))
          (reflect-field
           (classname
            (or (and attribute
                     (recursive-find [element-kw :value-namespaces attribute]))
                element-kw))
           (keyword->static-field value))))))

(defn add-default-atribute-value!
  [element-kw attribute-kw value]
  (swap! keyword-mapping
         update-in [element-kw :attributes attribute-kw] value))

(defn default-attributes
  [element-kw]
  (merge (when element-kw
           (default-attributes (get-in @keyword-mapping
                                       [element-kw :inherits])))
         (get-in @keyword-mapping [element-kw :attributes])))

(defn defelement
  [kw-name & {:as args}]
  (swap! keyword-mapping
         #(assoc % kw-name
                 (let [parent (if (contains? args :inherits)
                                (:inherits args)
                                :view)
                       classname (if (contains? args :classname)
                                   (:classname args)
                                   (get-in % [parent :classname]))]
                   (assoc args :inherits parent :classname classname))))
  (if-let [classname (:classname args)]
    (swap! reverse-mapping assoc classname kw-name)))

(ns neko.ui.menu
  (:require [neko.debug :refer [safe-for-ui]]
            [neko.ui :as ui]
            [neko.ui.mapping :refer [defelement]]
            [neko.ui.traits :refer [deftrait]]
            [neko.-utils :refer [call-if-nnil int-id]])
  (:import [android.view Menu MenuItem]
           [android.view View ActionMode$Callback]
           android.app.Activity))

(defn make-menu
  ([menu tree]
     (make-menu menu Menu/NONE tree))
  ([menu group tree]
     (doseq [[element-kw attributes & subelements] tree
             :when element-kw]
       (let [id (int-id (or (:id attributes) Menu/NONE))
             order (int-id (or (:order attributes) Menu/NONE))]
         (case element-kw
           :group
           (make-menu menu id subelements)
           :item
           (ui/apply-attributes
            :item
            (.add ^Menu menu ^int group ^int id ^int order "")
            (dissoc attributes :id :order) {})
           :menu
           (let [submenu (.addSubMenu ^Menu menu ^int group
                                      ^int id ^int order "")]
             (ui/apply-attributes :item (.getItem submenu)
                                  (dissoc attributes :id :order) {})
             (make-menu submenu subelements)))))))

(def ^{:doc 
       :private true}
  action-modes (atom {}))

(defn start-action-mode
  [activity & {:keys [on-create on-prepare on-clicked on-destroy]}]
  (when-not (@action-modes activity)
    (let [callback (reify ActionMode$Callback
                     (onCreateActionMode [this mode menu]
                       (call-if-nnil on-create mode menu))
                     (onPrepareActionMode [this mode menu]
                       (call-if-nnil on-prepare mode menu))
                     (onActionItemClicked [this mode item]
                       (call-if-nnil on-clicked mode item))
                     (onDestroyActionMode [this mode]
                       (swap! action-modes dissoc activity)
                       (call-if-nnil on-destroy mode)))
          am (.startActionMode ^Activity activity callback)]
      (swap! action-modes assoc activity am)
      am)))

(defn get-action-mode
  [activity]
  (@action-modes activity))

(defelement :item
  :classname MenuItem
  :inherits nil
  :traits [:show-as-action :on-menu-item-click :action-view])

(defn show-as-action-value
  [value]
  (if (keyword? value)
    (case value
      :always               MenuItem/SHOW_AS_ACTION_ALWAYS
      :collapse-action-view MenuItem/SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW
      :if-room              MenuItem/SHOW_AS_ACTION_IF_ROOM
      :never                MenuItem/SHOW_AS_ACTION_NEVER
      :with-text            MenuItem/SHOW_AS_ACTION_WITH_TEXT)
    value))

(deftrait :show-as-action
  [^MenuItem wdg, {:keys [show-as-action]} _]
  (let [value (if (vector? show-as-action)
                (apply bit-or (map show-as-action-value show-as-action))
                (show-as-action-value show-as-action))]
    (.setShowAsAction wdg value)))

(defn on-menu-item-click-call
  [handler-fn]
  (reify android.view.MenuItem$OnMenuItemClickListener
    (onMenuItemClick [this item]
      (safe-for-ui (handler-fn item))
      true)))

(defmacro on-menu-item-click
  [& body]
  `(on-menu-item-click-call (fn [~'item] ~@body)))

(deftrait :on-menu-item-click
  {:attributes [:on-click]}
  [^MenuItem wdg, {:keys [on-click]} _]
  (.setOnMenuItemClickListener wdg (on-menu-item-click-call on-click)))

(deftrait :action-view
  {:attributes [:action-view :context]
   :applies? (:action-view attrs)}
  [^MenuItem wdg, {:keys [action-view context] :as attrs} _]
  (let [view (if (instance? View action-view)
               action-view
               (ui/make-ui-element context action-view {:menu-item wdg}))]
    (.setActionView wdg ^View view)))

(ns neko.ui.traits
  (:require [neko.ui.mapping :as kw]
            [neko.resource :as res]
            [neko.listeners.view :as view-listeners]
            [neko.listeners.text-view :as text-view-listeners]
            [neko.listeners.adapter-view :as adapter-view]
            neko.listeners.search-view
            [neko.-utils :refer [memoized int-id]])
  (:import [android.widget LinearLayout$LayoutParams ListView TextView SearchView
            ImageView RelativeLayout RelativeLayout$LayoutParams
            AbsListView$LayoutParams FrameLayout$LayoutParams Gallery$LayoutParams]
           [android.view View ViewGroup$LayoutParams
            ViewGroup$MarginLayoutParams]
           android.graphics.Bitmap android.graphics.drawable.Drawable
           android.net.Uri
           android.util.TypedValue
           android.content.Context
           java.util.HashMap
           clojure.lang.Keyword))

(defmulti apply-trait
  (fn [trait widget attributes-map options-map]
    trait))

(defn add-attributes-to-meta
  [meta attr-list trait]
  (reduce (fn [m att]
            (update-in m [:attributes att]
                       #(if %
                          (conj % trait)
                          #{trait})))
          meta attr-list))

(defmacro deftrait
  [name & args]
  (let [[docstring args] (if (string? (first args))
                           [(first args) (next args)]
                           [nil args])
        [param-map args] (if (map? (first args))
                           [(first args) (next args)]
                           [{} args])
        attrs-sym (gensym "attributes")
        match-pred (cond (:applies? param-map)
                         (:applies? param-map)
                         (:attributes param-map)
                         `(some ~attrs-sym ~(:attributes param-map))
                         :else `(~name ~attrs-sym))
        [arglist & codegen-body] args
        dissoc-fn (if (:attributes param-map)
                    `(fn [a#] (apply dissoc a# ~(:attributes param-map)))
                    `(fn [a#] (dissoc a# ~name)))]
    `(do
       (alter-meta! #'apply-trait
                    (fn [m#]
                      (-> m#
                          (assoc-in [:trait-doc ~name] ~docstring)
                          (add-attributes-to-meta
                           (or ~(:attributes param-map) [~name]) ~name))))
       (defmethod apply-trait ~name
         [trait# widget# ~attrs-sym options#]
         (let [~arglist [widget# ~attrs-sym options#]]
           (if ~match-pred
             (let [result# (do ~@codegen-body)
                   attr-fn# ~dissoc-fn]
               (if (map? result#)
                 [(:attributes-fn result# attr-fn#)
                  (:options-fn result# identity)]
                 [attr-fn# identity]))
             [identity identity]))))))

(alter-meta! #'deftrait
             assoc :arglists '([name docstring? param-map? [params*] body]))

(deftrait :def
  [wdg {:keys [def]} _]
  (assert (and (symbol? def) (namespace def)))
  (intern (symbol (namespace def)) (symbol (name def)) wdg))

(deftrait :text
  [^TextView wdg, {:keys [text] :or {text ""}} _]
  (.setText wdg ^CharSequence (res/get-string (.getContext wdg) text)))

(defn- kw->unit-id [unit-kw]
  (case unit-kw
    :px TypedValue/COMPLEX_UNIT_PX
    :dp TypedValue/COMPLEX_UNIT_DIP
    :dip TypedValue/COMPLEX_UNIT_DIP
    :sp TypedValue/COMPLEX_UNIT_SP
    :pt TypedValue/COMPLEX_UNIT_PT
    :in TypedValue/COMPLEX_UNIT_IN
    :mm TypedValue/COMPLEX_UNIT_MM
    TypedValue/COMPLEX_UNIT_PX))

(memoized
 (defn- get-display-metrics
   [^Context context]
   (.. context (getResources) (getDisplayMetrics))))

(defn to-dimension [context value]
  (if (vector? value)
    (Math/round
     ^float (TypedValue/applyDimension
             (kw->unit-id (second value))
             (first value) (get-display-metrics context)))
    value))

(deftrait :text-size
  [^TextView wdg, {:keys [text-size]} _]
  (if (vector? text-size)
    (.setTextSize wdg (kw->unit-id (second text-size)) (first text-size))
    (.setTextSize wdg text-size)))

(deftrait :image
   [^ImageView wdg, {:keys [image]} _]
  (condp instance? image
    Bitmap (.setImageBitmap wdg image)
    Drawable (.setImageDrawable wdg image)
    Uri (.setImageURI wdg image)
    ;; Otherwise assume `image` to be resource ID.
    (.setImageResource wdg image)))

(def ^:private margin-attributes [:layout-margin
                                  :layout-margin-left :layout-margin-top
                                  :layout-margin-right :layout-margin-bottom])

(defn- apply-margins-to-layout-params
  [context, ^ViewGroup$MarginLayoutParams params, attribute-map]
  (let [common (to-dimension context (attribute-map :layout-margin 0))
        [l t r b] (map #(to-dimension context (attribute-map % common))
                       (rest margin-attributes))]
    (.setMargins params l t r b)))

(deftrait :default-layout-params
  {:attributes [:layout-width :layout-height]
   :applies? (and (or layout-width layout-height) (nil? container-type))}
  [^View wdg, {:keys [layout-width layout-height]} {:keys [container-type]}]
  (let [^int width (->> (or layout-width :wrap)
                        (kw/value :layout-params)
                        (to-dimension (.getContext wdg)))
        ^int height (->> (or layout-height :wrap)
                         (kw/value :layout-params)
                         (to-dimension (.getContext wdg)))]
    (.setLayoutParams wdg (ViewGroup$LayoutParams. width height))))

(deftrait :linear-layout-params
  {:attributes (concat margin-attributes [:layout-width :layout-height
                                          :layout-weight :layout-gravity])
   :applies? (= container-type :linear-layout)}
  [^View wdg, {:keys [layout-width layout-height layout-weight layout-gravity]
               :as attributes}
   {:keys [container-type]}]
  (let [^int width (->> (or layout-width :wrap)
                        (kw/value :layout-params)
                        (to-dimension (.getContext wdg)))
        ^int height (->> (or layout-height :wrap)
                         (kw/value :layout-params)
                         (to-dimension (.getContext wdg)))
        weight (or layout-weight 0)
        params (LinearLayout$LayoutParams. width height weight)]
    (apply-margins-to-layout-params (.getContext wdg) params attributes)
    (when layout-gravity
      (set! (. params gravity)
            (kw/value :layout-params layout-gravity :gravity)))
    (.setLayoutParams wdg params)))

(def ^:private relative-layout-attributes
  ;; Hard-coded number values are attributes that appeared since
  ;; Android Jellybean.
  {:standalone {:layout-align-parent-bottom  RelativeLayout/ALIGN_PARENT_BOTTOM
                :layout-align-parent-end     21 ; RelativeLayout/ALIGN_PARENT_END
                :layout-align-parent-left    RelativeLayout/ALIGN_PARENT_LEFT
                :layout-align-parent-right   RelativeLayout/ALIGN_PARENT_RIGHT
                :layout-align-parent-start   20 ; RelativeLayout/ALIGN_PARENT_START
                :layout-align-parent-top     RelativeLayout/ALIGN_PARENT_TOP
                :layout-center-horizontal    RelativeLayout/CENTER_HORIZONTAL
                :layout-center-vertical      RelativeLayout/CENTER_VERTICAL
                :layout-center-in-parent     RelativeLayout/CENTER_IN_PARENT}
   :with-id    {:layout-above                RelativeLayout/ABOVE
                :layout-align-baseline       RelativeLayout/ALIGN_BASELINE
                :layout-align-bottom         RelativeLayout/ALIGN_BOTTOM
                :layout-align-end            19 ; RelativeLayout/ALIGN_END
                :layout-align-left           RelativeLayout/ALIGN_LEFT
                :layout-align-right          RelativeLayout/ALIGN_RIGHT
                :layout-align-start          18 ; RelativeLayout/ALIGN_START
                :layout-align-top            RelativeLayout/ALIGN_TOP
                :layout-below                RelativeLayout/BELOW
                :layout-to-end-of            17 ; RelativeLayout/END_OF
                :layout-to-left-of           RelativeLayout/LEFT_OF
                :layout-to-right-of          RelativeLayout/RIGHT_OF
                :layout-to-start-of          16 ; RelativeLayout/START_OF
                }})

(def ^:private all-relative-attributes
  (apply concat [:layout-width :layout-height
                 :layout-align-with-parent-if-missing]
         (map keys (vals relative-layout-attributes))))

(deftrait :relative-layout-params
  {:attributes (concat all-relative-attributes margin-attributes)
   :applies? (= container-type :relative-layout)}
  [^View wdg, {:keys [layout-width layout-height
                      layout-align-with-parent-if-missing] :as attributes}
   {:keys [container-type]}]
  (let [^int width (->> (or layout-width :wrap)
                        (kw/value :layout-params)
                        (to-dimension (.getContext wdg)))
        ^int height (->> (or layout-height :wrap)
                         (kw/value :layout-params)
                         (to-dimension (.getContext wdg)))
        lp (RelativeLayout$LayoutParams. width height)]
    (when-not (nil? layout-align-with-parent-if-missing)
      (set! (. lp alignWithParent) layout-align-with-parent-if-missing))
    (doseq [[attr-name attr-id] (:standalone relative-layout-attributes)]
      (when (= (attr-name attributes) true)
        (.addRule lp attr-id)))
    (doseq [[attr-name attr-id] (:with-id relative-layout-attributes)]
      (when (contains? attributes attr-name)
        (.addRule lp attr-id (int-id (attr-name attributes)))))
    (apply-margins-to-layout-params (.getContext wdg) lp attributes)
    (.setLayoutParams wdg lp)))

(deftrait :listview-layout-params
  {:attributes [:layout-width :layout-height :layout-view-type]
   :applies? (= container-type :abs-listview-layout)}
  [^View wdg, {:keys [layout-width layout-height layout-view-type]
               :as attributes}
   {:keys [container-type]}]
  (let [^int width (->> (or layout-width :wrap)
                        (kw/value :layout-params)
                        (to-dimension (.getContext wdg)))
        ^int height (->> (or layout-height :wrap)
                         (kw/value :layout-params)
                         (to-dimension (.getContext wdg)))]
    (.setLayoutParams
     wdg (if layout-view-type
           (AbsListView$LayoutParams. width height layout-view-type)
           (AbsListView$LayoutParams. width height)))))

(deftrait :gallery-layout-params
  {:attributes [:layout-width :layout-height]
   :applies? (= container-type :gallery)}
  [^View wdg, {:keys [layout-width layout-height]
               :as attributes}
   {:keys [container-type]}]
  (let [^int width (->> (or layout-width :wrap)
                        (kw/value :layout-params)
                        (to-dimension (.getContext wdg)))
        ^int height (->> (or layout-height :wrap)
                         (kw/value :layout-params)
                         (to-dimension (.getContext wdg)))]
    (.setLayoutParams wdg (Gallery$LayoutParams. width height))))

(deftrait :frame-layout-params
   {:attributes (concat margin-attributes [:layout-width :layout-height
                                                    :layout-gravity])
             :applies? (= container-type :frame-layout)}
  [^View wdg, {:keys [layout-width layout-height layout-gravity]
               :as attributes}
   {:keys [container-type]}]
  (let [^int width (->> (or layout-width :wrap)
                        (kw/value :layout-params)
                        (to-dimension (.getContext wdg)))
        ^int height (->> (or layout-height :wrap)
                         (kw/value :layout-params)
                         (to-dimension (.getContext wdg)))
        params (FrameLayout$LayoutParams. width height)]
    (apply-margins-to-layout-params (.getContext wdg) params attributes)
    (when layout-gravity
      (set! (. params gravity)
            (kw/value :layout-params layout-gravity :gravity)))
    (.setLayoutParams wdg params)))

(deftrait :padding
  {:attributes [:padding :padding-bottom :padding-left
                :padding-right :padding-top]}
  [^View wdg {:keys [padding padding-bottom padding-left
                     padding-right padding-top]} _]
  (let [ctx (.getContext wdg)]
    (.setPadding wdg
                 (to-dimension ctx (or padding-left padding 0))
                 (to-dimension ctx (or padding-top padding 0))
                 (to-dimension ctx (or padding-right padding 0))
                 (to-dimension ctx (or padding-bottom padding 0)))))

(deftrait :container
  {:applies? (constantly true)}
  [wdg _ __]
  (let [kw (kw/keyword-by-classname (type wdg))
        container-type (-> (kw/get-keyword-mapping) kw :container-type)]
    {:options-fn #(assoc % :container-type (or container-type kw))}))

(deftrait :on-click
  [^View wdg, {:keys [on-click]} _]
  (.setOnClickListener wdg (view-listeners/on-click-call on-click)))

(deftrait :on-create-context-menu
  [^View wdg, {:keys [on-create-context-menu]} _]
  (.setOnCreateContextMenuListener
   wdg (view-listeners/on-create-context-menu-call on-create-context-menu)))

(deftrait :on-focus-change
  [^View wdg, {:keys [on-focus-change]} _]
  (.setOnFocusChangeListener
   wdg (view-listeners/on-focus-change-call on-focus-change)))

(deftrait :on-key
  [^View wdg, {:keys [on-key]} _]
  (.setOnKeyListener wdg (view-listeners/on-key-call on-key)))

(deftrait :on-long-click
  [^View wdg, {:keys [on-long-click]} _]
  (.setOnLongClickListener
   wdg (view-listeners/on-long-click-call on-long-click)))

(deftrait :on-touch
  [^View wdg, {:keys [on-touch]} _]
  (.setOnTouchListener wdg (view-listeners/on-touch-call on-touch)))

(deftrait :on-query-text
  {:attributes [:on-query-text-change :on-query-text-submit]}
  [^SearchView wdg, {:keys [on-query-text-change on-query-text-submit]}
   {:keys [menu-item]}]
  (.setOnQueryTextListener
   wdg (neko.listeners.search-view/on-query-text-call
        (if (and menu-item on-query-text-change)
          (fn [q] (on-query-text-change q menu-item))
          on-query-text-change)
        (if (and menu-item on-query-text-submit)
          (fn [q] (on-query-text-submit q menu-item))
          on-query-text-submit))))

(deftrait :on-editor-action
  [^TextView wdg, {:keys [on-editor-action]} _]
  (.setOnEditorActionListener wdg (text-view-listeners/on-editor-action-call on-editor-action)))

(deftrait :id-holder
  [^View wdg, _ __]
  (.setTag wdg (HashMap.))
  {:options-fn #(assoc % :id-holder wdg)})

(deftrait :id
  [^View wdg, {:keys [id]} {:keys [^View id-holder]}]
  (.setId wdg (int-id id))
  (when id-holder
    (.put ^HashMap (.getTag id-holder) id wdg)))

(deftrait :on-item-click
  [^ListView wdg, {:keys [on-item-click]} _]
  (.setOnItemClickListener wdg (adapter-view/on-item-click-call on-item-click)))