(ns stone.crypto
  (:require
   [wisp.runtime :refer [identity odd? even? dictionary? dictionary
                         keys vals key-values merge satisfies?
                         contains-vector? map-dictionary error?
                         string? number? date? boolean? re-pattern?
                         object? nil? true? false? re-find re-matches
                         re-pattern inc dec str char int subs and or
                         print to-string = max min fn? vector?]]
   [wisp.ast :refer [symbol symbol? keyword? keyword-name name
                     namespace gensym unquote? unquote-splicing?
                     quote? syntax-quote? quote-string pr-str
                     meta with-meta]]
   [wisp.sequence :refer [lazy-seq lazy-seq? list? list cons
                          sequential? reverse map filter reduce
                          count empty? first second third rest
                          last butlast take take-while drop conj
                          assoc concat seq seq? vec sort repeat
                          every? some partition interleave nth]]
   [wisp.string :refer [split split-lines join upper-case lower-case
                        capitalize pattern-escape replace-first replace
                        blank? reverse triml trimr trim]
                        :rename {reverse string-reverse}]
   [wisp.expander :refer [macroexpand]]
   [jsyaml]
   [Immutable :refer [List OrderedSet Map Seq]]
   [Handlebars :refer [compile]]
   ;;[Bluebird :refer [Promise]]
   [EthereumjsUtil]
   [TreeView]
   [_]
   [jQuery :as $]))

(defn init
  [config]
  )

(defn create-identity
  []
  (-> (crypto.subtle.generateKey {:name "ECDSA"
                                  :namedCurve "P-256"}
                                 true
                                 ["sign", "verify"])
      (.then (fn [k]
               (Promise.all [k
                             (crypto.subtle.exportKey "jwk" k.publicKey)
                             (crypto.subtle.exportKey "jwk" k.privateKey)])))
      (.then (fn [keys]
               {:ecdsa (get keys 0)
                :ecdsa-exp {:public (get keys 1)
                            :private (get keys 2)}}))))

(defn create-ecdh
  []
  (-> (crypto.subtle.generateKey {:name "ECDH"
                                  :namedCurve "P-256"}
                                 true
                                 ["deriveKey" "deriveBits"])
      (.then (fn [k]
               (Promise.all [k
                             (crypto.subtle.exportKey "jwk" k.publicKey)
                             (crypto.subtle.exportKey "jwk" k.privateKey)])))
      (.then (fn [keys]
               {:ecdh (get keys 0)
                :ecdh-exp {:public (get keys 1)
                           :private (get keys 2)}}))))

(set! window.create-identity create-identity)
(set! window.create-ecdh create-ecdh)