(ns ts.travelling-salesman)
(def numcities 20)
;go definira vkupniot broj na gradovi
;***treba da isprobate so razlicen broj na gradovi***,
;no vnimavajte kako toa ke se dorazi na ostanatiot del od skriptata

(defn citylist
  ([n] (citylist [] n))
  ([res n]
    (cond
      (zero? n) (vec (reverse res))
      :else (recur (conj res (keyword (str (char (+ (int \A) (dec n)))))) (dec n)))))
;funkcija koja vraka lista od n posledovatelni karakteri pocnuvajki od "A"

(def cities (citylist numcities))
;definicija na var koj ke se koristi kako  lista na iminja na gradovite vo problemot

(defn coord-list
  ([] (coord-list {} cities))
  ([result keys]
    (cond
      (empty? keys) result
      :else (recur (assoc result  (first keys) (vector-of :int (rand 1000) (rand 1000))) (rest keys))))
  	)
;funkcija koja za vlezna lista od karakteri generira mapa (hash) taka sto
;sekoj karakter se zema za kluc vo mapata
;kon sekoj kluc se pridruzuva vektor so dva elementi [x y] koi treba da odgovaraat na koordinati na klucot
;koordinatite se postavuvaat kako slucajni broevi vo opsegot pomegu 0 i 999
;***vo ramki na ovaa funkcija probajte da go menuvate opsegot od koj se izbiraat koordinatite***

(def coordinates (coord-list))
;definicija na var koj se koristi kako mapa za site gradovi vo problemot pridruzeni so nivnite koordinati

(defn square [x] (* x x))
;funkcija koja presmetuva kvadrat na vlezen broj

(defn distance [city1 city2]
  (let [c1 (city1 coordinates)
        c2 (city2 coordinates)]
    (Math/sqrt
      (+ (square (- (first c1) (first c2)))
         (square (- (second c1) (second c2)))
         			)
      		)
    	))
;funkcija koja presmetuva rastojanie pomegu dva grada
;kako vlez gi prima klucevite na gradovite od mapata kade gi cuvame

(defn rand-position [v]
  (int (rand (count v))))
;funkcija koja za vlezen vektor ke vi vrati slucajna pozicija vo ramki na vektorot
;vnimavajte ja vraka pozicijata, a ne elementot na taa pozicija

(defn routelength
  ([r] (routelength r (distance (first r) (nth r (dec (count r))))))
  ([r total] (cond (= (count r) 1) total :else (recur (rest r) (+ total (distance (first r) (nth r 1))))))
  )
;funkcija koja treba da presmeta dolzina na nekoj redosled na izminuvanje na gradovite
;redosledot treba da bide vektor vo koj sekoj element ke pretstavuva kluc od eden od gradovite
;ne zaboravajte deka vo vkupnata dolzina treba da go zemete vo predvid i vrakanjeto kon posledniot grad (rastojanie od posledniot element vo vektorot do prviot)
;funkcijata treba da ima eden argument - vektor za patekata
;realizirajte ja so tail rekurzija

(defn remove-subvec [v f t] (into [] (concat (subvec v 0 f) (subvec v t))))

(defn insert [n p l] (let [a (subvec l 0 p) b (subvec l p)] (into [] (concat a n b))))

(defn displacement [v]
  (let [a (rand-position v) b (rand-position v) c (min a b) d (max a b) nov-vec (remove-subvec v c d)]
    (cond
      (< (- d c) 2) (displacement v)
      :else (insert (subvec v c d) (rand-position nov-vec) nov-vec)
      )
    )
  )

;funkcija koja treba da ja implementira displacement modifikacijata na dadena pateka
;na vlez dobiva pateka kako vektor i treba da ja promeni spored displacement
;se zema podvektor od vlezniot so slucajna pocetna i krajna pozicija, za da ima smisla promenata treba podvektorot da ima dolzina pogolema od 1
;podvektorot treba da se "otstrani" od vlezniot vektor so sto se dobiva "nov" skraten vektor
;podvektorot treba da se vmetne vo "skrateniot" vektor na slucajna pozicija

(defn swap [v i1 i2]  (assoc v i2 (v i1) i1 (v i2)))

(defn exchange [v] (let [a (rand-position v) b (rand-position v)] (cond (= a b) (exchange v) :else (swap v a b))))
;funkcija koja treba da ja implementira exchange modifikacijata na dadena pateka
;na vlez dobiva pateka kako vektor i treba da ja promeni spored exchange
;se zemaat dve slucajni pozicii vlezniot vektor, za da ima smisla promenata treba dvete pozicii da bidat razlicni
;elementite koi se naogaat na dvete slucajno izbrani pozicii si gi zamenuvaat mestata


(defn insertion [v] (let [pos (rand-position v) el (nth v pos) nv (remove-subvec v pos (inc pos))] (insert [el] (rand-position nv) nv)))
;funkcija koja treba da ja implementira insertion modifikacijata na dadena pateka
;na vlez dobiva pateka kako vektor i treba da ja promeni spored insertion
;se zema slucajna pozicija od vlezniot vektor, elementot koj se naoga na taa pozicija se "otstranuva" od vlezniot vektor i se dobiva "nov skraten" vektor
;elementot koj prethodno go "otstranivme" se vraka nazad vo "noviot skraten" vektor, no na slucajna pozicija


(defn inversion [v]
  (let [a (rand-position v) b (rand-position v) c (min a b) d (max a b) nov-vec (remove-subvec v c d)]
    (cond
      (< (- d c) 2) (displacement v)
      :else (insert (into [] (reverse (subvec v c d))) (rand-position nov-vec) nov-vec)
      )
    )
  )

;funkcija koja treba da ja implementira inversion modifikacijata na dadena pateka
;na vlez dobiva pateka kako vektor i treba da ja promeni spored inversion
;se zema podvektor od vlezniot so slucajna pocetna i krajna pozicija, za da ima smisla promenata treba podvektorot da ima dolzina pogolema od 1
;podvektorot treba da se "otstrani" od vlezniot vektor so sto se dobiva "nov" skraten vektor
;podvektorot treba da se prevrti i da se vmetne vo "skrateniot" vektor na slucajna pozicija


(defn scramble [v]
  (let [a (rand-position v) b (rand-position v) c (min a b) d (max a b) nov-vec (remove-subvec v c d)]
    (cond
      (< (- d c) 2) (displacement v)
      :else (insert (shuffle (subvec v c d)) (rand-position nov-vec) nov-vec)
      )
    )
  )
;funkcija koja treba da ja implementira scramble modifikacijata na dadena pateka
;na vlez dobiva pateka kako vektor i treba da ja promeni spored scramble
;se zema podvektor od vlezniot so slucajna pocetna i krajna pozicija, za da ima smisla promenata treba podvektorot da ima dolzina pogolema od 1
;podvektorot treba da se "otstrani" od vlezniot vektor so sto se dobiva "nov" skraten vektor
;podvektorot treba da se izmesa (shuffle) i da se vmetne vo "skrateniot" vektor na slucajna pozicija


(def initial (shuffle cities))
;definicija na var so koj ja inicijalizirame patekata niz gradovite

(def best-route (ref initial))
;treba da definirate referenca (ref) vo koja ke se cuva najdobrata pateka kako vektor

(def best-length (ref (routelength initial)))
;treba da definirate referenca (ref) vo koja ke se cuva dolzinata na najdobrata pateka

(def maximprov 100)
(def num-improv (ref maximprov))
;definicija na referenca za broj na podobruvanja koi ocekuvame agentite da gi napravat za da zavrsi skriptata
;***isprobajte razlicni varijanti za vrednosta na ovaa referenca i iskomentirajte sto se slucuva pri mali/golemi vrednosti i pri razlicen broj na gradovi***


(def improv-operation (ref ()))
;definicija na var za lista vo koja ke se cuvaat site operacii koi agentite gi izvrsile i koi donele podobruvanje na patekata

(defn fn-name
  [f]
  (first (re-find #"(?<=\$)([^@]+)(?=@)" (str f))))
;funkcija koja koristi regularen izraz za da od dadena funkcija vo runtime go ekstrahira samo nejzinoto ime


(def displacement-agent (agent initial))
(def exchange-agent (agent initial)) ;definirajte agent so pocetna sostojba)
(def insertion-agent (agent initial));definirajte agent so pocetna sostojba)
(def inversion-agent (agent initial)) ;definirajte agent so pocetna sostojba)
(def scramble-agent (agent initial)) ;definirajte agent so pocetna sostojba)
;definicii za agentite koi ke go resavaat problemot
;definirate po eden agent za sekoja mozna operacija na promena na patekata
;sto bi znacelo deka sekoj eden od ovie agenti ke probuva da go resi problemot so taa promena,
;a krajnoto resenie ke bide kombinacija na site

(def num-tries (atom 1000))
;definicija na var za broj na obidi na sekoj od agentite
;ovaa vrednost e neophodna kako ogranicuvanje bidejki ako se postavi loso brojot na podobruvanja moze da otideme vo overflow
;istiot problem ke se javi ako brojot na obidi e mnogu golem
;***probajte da eksperimentirate so ovaa vrednost i komentirajte koga stanuva problematicna, probajte da najdete objasnuvanje online za problemot koj se javuva***

(defn update [v f]
  ;vasiot kod ovde
      (let [nov-vec (f v) length (routelength nov-vec)]
        (cond
          (> length @best-length) v
          :else (do (dosync (ref-set best-length length)) (dosync (ref-set best-route nov-vec)) (dosync (alter num-improv dec))
                    (dosync (ref-set improv-operation (conj @improv-operation (fn-name f))) nov-vec))
         )
      )
)

;funkcija koja dokolku se ispolneti uslovi treba da napravi azuriranje na referencite best-route, best-length, num-improv, improv-operation
;na vlez dobiva dva argumenti: vektor za momentalna pateka i funkcija koja treba da se primeni na takvata pateka za da se promeni
;referencite se menuvaat samo ako promenetata pateka e podobra od tekovnata
;ovaa funkcija treba da bide iskoristena od strana na agentite koi go baraat resenieto,t.e. ova e funkcijata koja mu se praka na sekoj eden agent
;pri koristenje na send funkcijata, momentalnata sostojba na agentot ke bide postavena kako prv argument na funkcijata
;rezultatot od izvrsuvanjeto na funkcijata ke bide nova sostojba na agentot
;vtoriot argument na funkcijata ukazuva na toa koja promena da se iskoristi za da se vidi dali agentot ke si ja promeni sostojbata
;primer: (send displacement-agent update displacement),
;sto bi znacelo deka vrz momentalnata sostojba na agentot so ime displacement-agent ja primenuvame update funkcijata vo koja ke se proba da se napravi azuriranje so displacement funkcijata

(defn show[]
  (do
    	(println "Initial route was" initial "with length" (routelength initial))
    	(println (- maximprov @num-improv) "improvements made")
    	(println "The following operations were made" @improv-operation)
    	(println "Best route is" @best-route "with length" @best-length)))
;funkcija za prikaz na resenieto

(defn main []
  (cond
    (<= @num-improv 0) (do (println "1") (shutdown-agents) (show))
    (< @num-tries 1) (do (await-for 1000 displacement-agent exchange-agent insertion-agent inversion-agent scramble-agent) (show))
    :else (do
            (send exchange-agent update exchange)
            (send displacement-agent update displacement)
            (send insertion-agent update insertion)
            (send inversion-agent update inversion)
            (send scramble-agent update scramble)
            (swap! num-tries dec)
            (main)
            ))
)

;glavnata funkcija preku koja go resavate problemot
;treba da zemete vo predvid nekolku moznosti:
;1. funkcijata da zavrsi poradi dostignat broj na podobruvanja na resenieto
	;Vo ovoj slucaj potrebno e da gi prekinete site agenti koi seuste ne zavrsile i da go prikazete resenieto
;2. funkcijata da zavrsi poradi dostignat broj na obidi
	;Vo ovoj slucaj potrebno e da gi pocekate site agenti da zavrsat i potoa da go prikazete resenieto
;3. Ako ne e ispolnet nitu eden uslov za prekinuvanje potrebno na sekoj od agentite da mu ispratite soodveten update, da go namalite brojot na obidi i da napravite rekurziven povik