(ns coderloop.scientist2

   (:refer-clojure :only [])

   (:require rlm.ns-rlm rlm.light-base))

 (rlm.ns-rlm/ns-clone rlm.light-base)

 

 

 (use 'clojure.contrib.sql)

 (import 'org.gjt.mm.mysql.Driver)

 (use 'clojure.contrib.sql)

 (undef distinct case compile drop take sort)

 (use 'clojureql.core)

 (import 'java.io.File)

 (use '[clojure.java.io :only [copy]])

 (use '[clojure.contrib.shell-out :only [sh]])

 (use '[clojure.string :only [split]])

 (use '[coderloop [utils :only [md5]]])

 (import 'java.sql.Date)

 

 

 

 (def *port* 3306)

 

 (def *host* "localhost")

 

 (def *db-host* "localhost")

 

 (def *db-name* "clojure_rlm")

 

 (def *db* {:classname "com.mysql.jdbc.Driver"

 	   :subprotocol "mysql"

 	   :subname (str "//" *db-host* ":" *port* "/" *db-name*)

 	   :user "root"

 	   :password "sql1005025"})

 

 (def databases [:essay_scientists :scientists :ideas :scientist_whereabouts])

 

 

 

 

 (declare essays essay century contemps data eric scientists date->str date)

 

 (defn scientists []

   @(table *db* :essay_scientists))

 

 

 (defn contemps [s birth death]

   (sort-by (fn [s] [(:surname s) (:name s)])

 	   (map #(select-keys % [:name :surname])

 		@(select

 		  (table *db* :scientists)

 		  (where

 		   (and

 		    (< :birth_date death)

 		    (< birth :death_date)

 		    (not (= :name (:name s)))))))  ))

 	   

 (defn data [s]

   (let [locations

 	(sort-by

 	 :immigration_date

 	 (map #(select-keys % [:immigration_date :emigration_date :country])

 		      @(select

 			(table *db* :scientist_whereabouts)

 			(where

 		 (and

 		  (= :scientist_whereabouts.surname (:surname s))

 		  (= :scientist_whereabouts.name (:name s)))))))

 	 ideas

 	(sort-by

 	 #(.toLowerCase %)

 	 (map :idea

 	      @(select

 		(table *db* :ideas)

 		(where

 		 (and

 		  (= :ideas.surname (:surname s))

 		  (= :ideas.name (:name s)))))))

 	data

 	(first

 	 @(select

 	   (table *db* :scientists)

 	   (where

 	    (and 

 	     (= :scientists.surname (:surname s))

 	     (= :scientists.name (:name s))))))

 	birth (:birth_date data)

 	death (:death_date data)

 	contemp (contemps s birth death)]

     (merge data {:locations locations :contemps contemp  :ideas ideas})))

      

 (defn date->str [#^java.sql.Date d]

   (format "%02d/%02d/%04d"  (.getDate d) (inc (.getMonth d)) (+ 1900 (.getYear d))))

 

 (def strcat (partial apply str))

 

 (defn century [#^java.sql.Date d]

   (* 100 (clojure.core/unchecked-divide (+ 1900 (.getYear d)) 100)))

 

 (defn essay-map [s]

   (let [base (data s)

 	locations

 	(strcat

 	 (interpose

 	  ", "

 	  (map (fn [{:keys [emigration_date immigration_date country ]}]

 		 (str country " from " (date->str immigration_date) " to "

 		      (date->str emigration_date))) (:locations base))))

 	contemps

 	(strcat

 	 (interpose

 	  ", "

 	  (map (fn [{:keys [name surname]}]

 		 (str name " " surname))

 	       (:contemps base))))

 	birth-date (date->str (:birth_date base))

 	death-date (date->str (:death_date base))

 	century (century (:birth_date base))

 	lifespan

 	(str "["

 	     (:birth_place base) " " birth-date ", "

 	     (:death_place base) " " death-date

 	     "]")

 	ideas (strcat (interpose ", " (:ideas base)))

 	]

     {:lifespan lifespan :name (:name base) :surname (:surname base)

      :contemps contemps :locations locations :century century :ideas ideas}))

 

 (defn essay [s]

   (let [{:keys [lifespan name surname contemps locations century ideas]} (essay-map s)]

     (str name " " surname " " lifespan " is one of the most famous scientists of "

 	 century ". "

 	 "Between all " name "'s ideas we mention: " ideas ". "

 	 name " lived in: " locations ". "

 	 name " was a contemporary of " contemps ".\n\n"))) 

 	 

 (defn essays []

   (map essay (scientists)))

 

 (defn print-essays []

   (dorun (map print (essays))))

 

 (defn essays->str []

   (strcat (essays)))

 

 (defn main [[username password db-name]]

   (let [db-host *host*

 	db-port *port*

 	db {:classname "com.mysql.jdbc.Driver"

 	    :subprotocol "mysql"

 	    :subname (str "//" db-host ":" db-port "/" db-name)

 	    :user username

 	    :password password}]

     (binding [*db* db]

       (print-essays))))

 

 (if (command-line?)

   (main *command-line-args*))

     

     

 

 

 

 (def eric {:name "Erik 3802" :surname "Green 3802"})

 (def date (java.sql.Date. 4564654645))

 

 

 

 (defvar error-person

   {:name "Albert 3850" :surname "Newton 3850"}

   "this is the person in in which John 5750 is supposedly

    wrongly included my code says they're contempoaries,

    but the expected output disaggrees ")

 

 (defvar wrong-include

   {:name "John 5750" :surname  "Newton 5750"}

   "this one is inculded and supposedly should not be.")

 

 ;;coderloop.scientist2> (select-keys (data error-person) [:birth_date :death_date])

 ;;{:death_date #<Date 0226-10-18>, :birth_date #<Date 0166-10-16>}

 ;;coderloop.scientist2> (select-keys (data wrong-include) [:birth_date :death_date])

 ;;{:death_date #<Date 0226-01-01>, :birth_date #<Date 0166-12-30>}

 

 ;; these exibit the same problem. They appear to be contemps,

 ;; but the expected output says that they're not!

 (defvar error-person2

   {:name "Erik 3851" :surname "Smith 3851"})

 

 (defvar wrong-include2

   {:name "Gil 5751" :surname "Smith 5751"})

 

 ;;coderloop.scientist2> (select-keys (data error-person2) [:birth_date :death_date])

 ;;{:death_date #<Date 0227-10-19>, :birth_date #<Date 0167-10-17>}

 ;;coderloop.scientist2> (select-keys (data wrong-include2) [:birth_date :death_date])

 ;;{:death_date #<Date 0227-01-02>, :birth_date #<Date 0167-12-31>}