(.using
 [library
  [lux (.except)
   [abstract
    [monad (.only do)]]
   [control
    ["[0]" exception (.only exception:)]
    ["<>" parser
     ["<[0]>" json (.only Parser)]]]
   [data
    [text
     ["%" \\format (.only format)]]]
   [math
    [number
     ["n" nat]
     ["i" int]
     ["f" frac]]]]]
 ["[0]" //
  ["[1]" license (.only Identification
                        Termination
                        Liability
                        Distribution
                        Commercial
                        Extension
                        Entity Black_List
                        URL Attribution
                        Addendum
                        License)
   ["[0]" time (.only Period)]
   ["[0]" copyright]]])

(def identification
  (Parser Identification)
  (<json>.object
    (all <>.and
         (<json>.field "name" <json>.string)
         (<json>.field "version" <json>.string))))

(exception: .public (cannot_use_fractional_amount [amount Frac])
  (exception.report
   "Amount" (%.frac amount)))

(exception: .public (cannot_use_negative_amount [amount Int])
  (exception.report
   "Amount" (%.int amount)))

(def amount
  (Parser Nat)
  (do <>.monad
    [amountF <json>.number
     #let [amountI (f.int amountF)]
     _ (<>.assert (exception.construct ..cannot_use_fractional_amount [amountF])
                  (f.= amountF
                       (i.frac amountI)))
     _ (<>.assert (exception.construct ..cannot_use_negative_amount [amountI])
                  (i.> +0 amountI))]
    (wrap (.nat amountI))))

(exception: .public (invalid_period [period (Period Nat)])
  (exception.report
   "Start" (%.nat (the time.#start period))
   "End" (%.nat (the time.#end period))))

(def period
  (Parser (Period Nat))
  (<json>.object
    (do <>.monad
      [start (<json>.field "start" ..amount)
       end (<json>.field "end" ..amount)
       #let [period [time.#start start
                     time.#end end]]
       _ (<>.assert (exception.construct ..invalid_period [period])
                    (n.<= end start))]
      (wrap period))))

(def copyright_holder
  (Parser copyright.Holder)
  (<json>.object
    (all <>.and
         (<json>.field "name" <json>.string)
         (<json>.field "period" ..period))))

(def termination
  (Parser Termination)
  (<json>.object
    (all <>.and
         (<json>.field "patent retaliation?" <json>.boolean)
         (<json>.field "termination period" ..amount)
         (<json>.field "grace period" ..amount))))

(def liability
  (Parser Liability)
  (<json>.object
    (all <>.and
         (<json>.field "can accept?" <json>.boolean)
         (<json>.field "disclaim high risk?" <json>.boolean))))

(def distribution
  (Parser Distribution)
  (<json>.object
    (all <>.and
         (<json>.field "can re-license?" <json>.boolean)
         (<json>.field "can multi-license?" <json>.boolean))))

(def commercial
  (Parser Commercial)
  (<json>.object
    (all <>.and
         (<json>.field "can sell?" <json>.boolean)
         (<json>.field "require contributor credit?" <json>.boolean)
         (<json>.field "allow contributor endorsement?" <json>.boolean))))

(def extension
  (Parser Extension)
  (<json>.object
    (all <>.and
         (<json>.field "same license?" <json>.boolean)
         (<json>.field "must be distinguishable?" <json>.boolean)
         (<json>.field "notification period" (<json>.nullable ..period))
         (<json>.field "must describe modifications?" <json>.boolean))))

(def entity
  (Parser Entity)
  <json>.string)

(def black_list
  (Parser Black_List)
  (<json>.object
    (all <>.and
         (<json>.field "justification" (<json>.nullable <json>.string))
         (<json>.field "entities" (<json>.array (<>.many ..entity))))))

(def url
  (Parser URL)
  <json>.string)

(def attribution
  (Parser Attribution)
  (<json>.object
    (all <>.and
         (<json>.field "copyright-notice" <json>.string)
         (<json>.field "phrase" (<json>.nullable <json>.string))
         (<json>.field "url" ..url)
         (<json>.field "image" (<json>.nullable ..url)))))

(def addendum
  (Parser Addendum)
  (<json>.object
    (all <>.and
         (<json>.field "commons clause?" <json>.boolean)
         )))

(def .public license
  (Parser License)
  (<json>.object
    (all <>.and
         (<json>.field "copyright-holders" (<json>.array (<>.many ..copyright_holder)))
         (<json>.field "identification" (<json>.nullable ..identification))
         (<json>.field "termination" ..termination)
         (<json>.field "liability" ..liability)
         (<json>.field "distribution" ..distribution)
         (<json>.field "commercial" ..commercial)
         (<json>.field "extension" ..extension)
         (<json>.field "black-lists" (<json>.array (<>.some ..black_list)))
         (<json>.field "attribution" (<json>.nullable ..attribution))
         (<>.default [//.#commons_clause? false]
                     (<json>.field "addendum" ..addendum))
         )))