; 주석은 세미콜론으로 시작해
; 기본 연산
(+ 1 2 3)        ; => 6
(* 2 3 4)        ; => 24
(- 10 3)         ; => 7
(/ 10 2)         ; => 5

; 문자열
(str "안녕" " " "클로저!")  ; => "안녕 클로저!"
(count "hello")              ; => 5

; 변수 정의 (def)
(def my-name "클로저 개발자")
(def pi 3.14159)

; 함수 정의 (defn)
(defn greet [name]
  (str "안녕하세요, " name "님!"))

(greet "재능넷 유저")  ; => "안녕하세요, 재능넷 유저님!"

; 조건문 (if)
(if (> 10 5)
  "10이 더 크다"
  "5가 더 크다")
; => "10이 더 크다"

; let으로 지역 변수 바인딩
(let [x 10
      y 20
      sum (+ x y)]
  (str "합계: " sum))
; => "합계: 30"

; 벡터 (Vector) - 순서 있는 컬렉션, 인덱스 접근 O(1)
(def my-vec [1 2 3 4 5])
(get my-vec 0)    ; => 1
(nth my-vec 2)    ; => 3
(count my-vec)    ; => 5

; 리스트 (List) - 연결 리스트, 앞에서 추가 O(1)
(def my-list '(1 2 3 4 5))
(first my-list)   ; => 1
(rest my-list)    ; => (2 3 4 5)

; 맵 (Map) - 키-값 쌍
(def person {:name "김클로저"
             :age 30
             :job "개발자"})
(get person :name)   ; => "김클로저"
(:age person)        ; => 30  (키워드를 함수처럼 사용!)

; 셋 (Set) - 중복 없는 컬렉션
(def my-set #{1 2 3 4 5})
(contains? my-set 3)  ; => true
(contains? my-set 6)  ; => false

; 벡터 조작
(def v [1 2 3 4 5])

(conj v 6)          ; => [1 2 3 4 5 6]  (끝에 추가)
(assoc v 2 99)      ; => [1 2 99 4 5]   (인덱스 2를 99로)
(dissoc v 2)        ; 벡터에는 dissoc 안 씀
(subvec v 1 3)      ; => [2 3]          (슬라이싱)
(into [] (rest v))  ; => [2 3 4 5]      (첫 요소 제거)

; 원본은 그대로!
v  ; => [1 2 3 4 5]  변하지 않음!

; 맵 조작
(def m {:a 1 :b 2 :c 3})

(assoc m :d 4)      ; => {:a 1, :b 2, :c 3, :d 4}
(dissoc m :b)       ; => {:a 1, :c 3}
(update m :a inc)   ; => {:a 2, :b 2, :c 3}
(merge m {:d 4 :e 5}) ; => {:a 1, :b 2, :c 3, :d 4, :e 5}

; 중첩 맵 조작
(def nested {:user {:name "김클로저" :age 30}})
(assoc-in nested [:user :age] 31)
; => {:user {:name "김클로저", :age 31}}

(get-in nested [:user :name])
; => "김클로저"

(update-in nested [:user :age] inc)
; => {:user {:name "김클로저", :age 31}}

; map - 컬렉션의 각 요소에 함수 적용
(map inc [1 2 3 4 5])
; => (2 3 4 5 6)

(map #(* % 2) [1 2 3 4 5])
; => (2 4 6 8 10)

(map str [1 2 3])
; => ("1" "2" "3")

; filter - 조건에 맞는 요소만 추출
(filter even? [1 2 3 4 5 6])
; => (2 4 6)

(filter #(> % 3) [1 2 3 4 5])
; => (4 5)

; reduce - 컬렉션을 하나의 값으로 축약
(reduce + [1 2 3 4 5])
; => 15

(reduce * [1 2 3 4 5])
; => 120

(reduce (fn [acc x] (+ acc (* x x))) 0 [1 2 3 4 5])
; => 55  (1² + 2² + 3² + 4² + 5²)

; 조합해서 사용하기!
(->> [1 2 3 4 5 6 7 8 9 10]
     (filter even?)
     (map #(* % %))
     (reduce +))
; => 220  (2² + 4² + 6² + 8² + 10²)

; 스레딩 매크로 없이 (읽기 어려움 ㅠㅠ)
(str (clojure.string/upper-case
       (clojure.string/trim
         "  hello world  ")))
; => "HELLO WORLD"

; -> 스레딩 매크로 사용 (훨씬 읽기 쉬움!)
(-> "  hello world  "
    clojure.string/trim
    clojure.string/upper-case
    str)
; => "HELLO WORLD"

; ->> 스레딩 매크로 (컬렉션 처리에 유용)
(->> (range 1 11)
     (filter odd?)
     (map #(* % %))
     (reduce +))
; => 165  (1² + 3² + 5² + 7² + 9²)

; as-> 스레딩 매크로 (위치를 직접 지정)
(as-> 5 x
  (* x x)
  (+ x 10)
  (str "결과: " x))
; => "결과: 35"

; 클로저 예제
(defn make-adder [n]
  (fn [x] (+ x n)))  ; n을 캡처하는 클로저

(def add5 (make-adder 5))
(def add10 (make-adder 10))

(add5 3)   ; => 8
(add10 3)  ; => 13

; 더 실용적인 예제
(defn make-counter []
  (let [count (atom 0)]  ; atom은 변경 가능한 참조 (나중에 설명!)
    {:increment #(swap! count inc)
     :decrement #(swap! count dec)
     :value     #(deref count)}))

(def counter (make-counter))
((:increment counter))
((:increment counter))
((:increment counter))
((:value counter))  ; => 3

; partial - 함수의 일부 인자를 미리 적용
(def multiply-by-3 (partial * 3))
(multiply-by-3 5)   ; => 15
(multiply-by-3 10)  ; => 30

; 실용적인 예
(def add-tax (partial * 1.1))
(add-tax 1000)  ; => 1100.0
(add-tax 5000)  ; => 5500.0

; comp - 함수 합성
(def process-name
  (comp clojure.string/upper-case
        clojure.string/trim))

(process-name "  hello  ")  ; => "HELLO"

; juxt - 여러 함수를 동시에 적용
(def stats (juxt min max #(/ (reduce + %) (count %))))
(stats [3 1 4 1 5 9 2 6])
; => [1 9 31/8]  (최솟값, 최댓값, 평균)

; Atom 생성
(def counter (atom 0))
(def user-db (atom {}))

; 값 읽기
@counter        ; => 0  (deref와 동일)
(deref counter) ; => 0

; 값 변경 (swap! - 함수를 적용해서 변경)
(swap! counter inc)     ; => 1
(swap! counter + 5)     ; => 6
(swap! counter * 2)     ; => 12

; 값 교체 (reset! - 새 값으로 직접 교체)
(reset! counter 0)      ; => 0

; 실용적인 예: 사용자 DB 관리
(swap! user-db assoc :user1 {:name "김클로저" :age 30})
(swap! user-db assoc :user2 {:name "이함수형" :age 25})
(swap! user-db update-in [:user1 :age] inc)

@user-db
; => {:user1 {:name "김클로저", :age 31},
;     :user2 {:name "이함수형", :age 25}}

; 멀티스레드 환경에서도 안전!
(def safe-counter (atom 0))
(doall
  (pmap (fn [_] (swap! safe-counter inc))
        (range 1000)))
@safe-counter  ; => 1000  (항상 정확한 값!)

; 은행 계좌 예제 (STM으로 안전하게!)
(def account-a (ref 1000))
(def account-b (ref 500))

; 이체 함수
(defn transfer! [from to amount]
  (dosync  ; 트랜잭션 시작
    (when (>= @from amount)
      (alter from - amount)
      (alter to + amount)
      true)))

; 이체 실행
(transfer! account-a account-b 300)
; => true

@account-a  ; => 700
@account-b  ; => 800

; 동시에 여러 이체가 일어나도 안전!
; STM이 충돌을 감지하고 자동으로 재시도함
(future (transfer! account-a account-b 100))
(future (transfer! account-b account-a 50))

; 잠시 후...
(+ @account-a @account-b)  ; => 1500  (항상 총합 보존!)

; 매크로 정의 예제
; when 매크로 직접 구현해보기
(defmacro my-when [condition & body]
  `(if ~condition
     (do ~@body)
     nil))

; 사용
(my-when (> 10 5)
  (println "10이 더 크다!")
  (println "맞아!"))
; => 10이 더 크다!
; => 맞아!

; 매크로 확장 확인 (macroexpand)
(macroexpand '(my-when (> 10 5) (println "hello")))
; => (if (> 10 5) (do (println "hello")) nil)

; 실용적인 매크로 예제: 타이밍 측정
(defmacro time-it [& body]
  `(let [start# (System/nanoTime)
         result# (do ~@body)
         end# (System/nanoTime)]
     (println (str "실행 시간: "
                   (/ (- end# start#) 1000000.0)
                   "ms"))
     result#))

(time-it
  (Thread/sleep 100)
  (+ 1 2 3))
; => 실행 시간: 100.xxx ms
; => 6

; 로깅 매크로
(defmacro log-call [fn-name & args]
  `(do
     (println (str "[LOG] " ~fn-name " 호출: " ~@args))
     (~(symbol fn-name) ~@args)))

; 다양한 컬렉션에 동일한 함수 적용
(first [1 2 3])        ; => 1  (벡터)
(first '(1 2 3))       ; => 1  (리스트)
(first #{1 2 3})       ; => 1  (셋, 순서 불확정)
(first {:a 1 :b 2})    ; => [:a 1]  (맵은 키-값 쌍)

; 지연 시퀀스 (Lazy Sequence)
; 무한 시퀀스도 만들 수 있어!
(def natural-numbers (range))  ; 0부터 무한대까지
(take 10 natural-numbers)
; => (0 1 2 3 4 5 6 7 8 9)

; 피보나치 수열 (지연 시퀀스)
(def fibs
  (lazy-cat [0 1]
            (map + fibs (rest fibs))))

(take 10 fibs)
; => (0 1 1 2 3 5 8 13 21 34)

; 무한 시퀀스에서 필요한 만큼만 가져오기
(->> (range)
     (filter even?)
     (map #(* % %))
     (take 5))
; => (0 4 16 36 64)

; iterate - 함수를 반복 적용
(take 8 (iterate #(* 2 %) 1))
; => (1 2 4 8 16 32 64 128)

; cycle - 무한 반복
(take 7 (cycle [1 2 3]))
; => (1 2 3 1 2 3 1)

; repeat - 값 반복
(take 5 (repeat "hello"))
; => ("hello" "hello" "hello" "hello" "hello")

; 일반 방식 (중간 컬렉션 생성)
(->> [1 2 3 4 5 6 7 8 9 10]
     (filter even?)
     (map #(* % %))
     (into []))
; 중간에 (2 4 6 8 10) 컬렉션이 생성됨

; 트랜스듀서 방식 (중간 컬렉션 없음!)
(def xf
  (comp
    (filter even?)
    (map #(* % %))))

(into [] xf [1 2 3 4 5 6 7 8 9 10])
; => [4 16 36 64 100]

; transduce로 바로 reduce
(transduce xf + [1 2 3 4 5 6 7 8 9 10])
; => 220

; 채널에도 적용 가능 (core.async)
; (chan 10 xf)  ; 채널에 트랜스듀서 적용

; project.clj (Leiningen 프로젝트 설정)
(defproject my-web-app "0.1.0"
  :dependencies [[org.clojure/clojure "1.11.1"]
                 [ring/ring-core "1.9.6"]
                 [ring/ring-jetty-adapter "1.9.6"]
                 [compojure "1.7.0"]
                 [ring/ring-json "0.5.1"]])

; src/my_web_app/core.clj
(ns my-web-app.core
  (:require [compojure.core :refer :all]
            [compojure.route :as route]
            [ring.adapter.jetty :as jetty]
            [ring.middleware.json :as json]
            [ring.util.response :as response]))

; 데이터 저장소 (Atom 사용!)
(def users (atom [{:id 1 :name "김클로저" :age 30}
                  {:id 2 :name "이함수형" :age 25}]))

; 라우트 정의
(defroutes app-routes
  (GET "/" []
    (response/response "Clojure 웹 서버에 오신 걸 환영합니다!"))

  (GET "/users" []
    (response/response @users))

  (GET "/users/:id" [id]
    (let [user-id (Integer/parseInt id)
          user (first (filter #(= (:id %) user-id) @users))]
      (if user
        (response/response user)
        (response/not-found "사용자를 찾을 수 없습니다"))))

  (POST "/users" {body :body}
    (let [new-user (assoc body :id (inc (count @users)))]
      (swap! users conj new-user)
      (response/created "/users" new-user)))

  (route/not-found "페이지를 찾을 수 없습니다"))

; 미들웨어 적용
(def app
  (-> app-routes
      json/wrap-json-response
      json/wrap-json-body))

; 서버 시작
(defn -main []
  (jetty/run-jetty app {:port 3000 :join? false})
  (println "서버 시작! http://localhost:3000"))

; CSV 데이터 처리 예제
(require '[clojure.string :as str])
(require '[clojure.java.io :as io])

; 샘플 데이터
(def raw-data
  "이름,나이,점수,부서
  김클로저,30,95,개발
  이함수형,25,88,개발
  박불변,35,92,기획
  최동시성,28,78,개발
  정매크로,32,85,기획")

; 데이터 파싱 함수
(defn parse-csv [csv-str]
  (let [lines (str/split-lines (str/trim csv-str))
        headers (map keyword (str/split (first lines) #","))
        rows (rest lines)]
    (map (fn [row]
           (zipmap headers
                   (str/split (str/trim row) #",")))
         rows)))

(def employees (parse-csv raw-data))

; 데이터 분석
; 개발팀 평균 점수
(->> employees
     (filter #(= (:부서 %) "개발"))
     (map #(Integer/parseInt (:점수 %)))
     (fn [scores] (/ (reduce + scores) (count scores))))
; => 87  (개발팀 평균)

; 부서별 그룹핑
(group-by :부서 employees)
; => {"개발" [...], "기획" [...]}

; 점수 기준 정렬
(sort-by #(Integer/parseInt (:점수 %)) > employees)
; 점수 높은 순으로 정렬

; core.async 라이브러리 사용
(require '[clojure.core.async :as async
           :refer [chan go go-loop >! <! >!! <!! close!]])

; 채널 생성
(def ch (chan 10))

; 생산자 (Producer)
(go
  (doseq [i (range 5)]
    (>! ch (* i i))
    (println (str "전송: " (* i i))))
  (close! ch))

; 소비자 (Consumer)
(go-loop []
  (when-let [val (<! ch)]
    (println (str "수신: " val))
    (recur)))

; 파이프라인 처리
(def input-ch (chan 10))
(def output-ch (chan 10))

; 변환 파이프라인
(async/pipeline
  4  ; 병렬 처리 수
  output-ch
  (comp (filter even?) (map #(* % %)))
  input-ch)

; 데이터 전송
(go
  (doseq [i (range 10)]
    (>! input-ch i))
  (close! input-ch))

; 결과 수집
(go-loop [results []]
  (if-let [val (<! output-ch)]
    (recur (conj results val))
    (println "결과:" results)))

; 1. Java 설치 (JDK 11 이상 권장)
; https://adoptium.net/ 에서 다운로드

; 2. Clojure CLI 설치 (macOS)
; brew install clojure/tools/clojure

; 3. Leiningen 설치 (선택)
; brew install leiningen

; 4. 새 프로젝트 생성
; lein new app my-clojure-app
; 또는
; clojure -Tnew app :name myname/myapp

; 5. REPL 시작 (진짜 중요! Clojure 개발의 핵심)
; lein repl
; 또는
; clj

; 6. 코드 실행
; lein run
; 또는
; clj -M -m my-app.core