; 두 개의 은행 계좌를 Ref로 생성
(def account-a (ref 1000))  ; A 계좌: 1000원
(def account-b (ref 500))   ; B 계좌: 500원

; 현재 잔액 확인 (읽기는 트랜잭션 없이도 가능)
@account-a  ; => 1000
@account-b  ; => 500

; 단순 입금 (트랜잭션 필요)
(dosync
  (alter account-a + 100))  ; A 계좌에 100원 입금

@account-a  ; => 1100

; 계좌 이체 함수
(defn transfer [from-account to-account amount]
  (dosync
    (alter from-account - amount)  ; 출금
    (alter to-account + amount)))  ; 입금

; A 계좌에서 B 계좌로 300원 이체
(transfer account-a account-b 300)

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

; 여러 계좌 생성
(def accounts (vec (repeatedly 10 #(ref 1000))))

; 무작위 계좌 간 이체를 수행하는 함수
(defn random-transfer []
  (let [from-idx (rand-int 10)
        to-idx (rand-int 10)
        amount (rand-int 100)]
    (when (not= from-idx to-idx)
      (transfer (accounts from-idx) 
                (accounts to-idx) 
                amount))))

; 100개의 스레드에서 동시에 1000번씩 이체 실행
(defn stress-test []
  (let [threads (repeatedly 100 
                  #(Thread. 
                    (fn [] 
                      (dotimes [_ 1000] 
                        (random-transfer)))))]
    (doseq [t threads] (.start t))
    (doseq [t threads] (.join t))))

; 전체 잔액 확인 (항상 10000이어야 함)
(defn total-balance []
  (reduce + (map deref accounts)))

(stress-test)
(total-balance)  ; => 10000 (항상!)

(def counter (ref 0))

(dosync
  (alter counter inc)      ; counter를 1 증가
  (alter counter + 10))    ; counter에 10 더하기

@counter  ; => 11

; alter는 함수를 받아서 현재 값에 적용
(dosync
  (alter counter (fn [current-value] 
                   (* current-value 2))))

@counter  ; => 22

(def status (ref :idle))

(dosync
  (ref-set status :running))  ; 직접 값을 설정

@status  ; => :running

; 조건부 설정도 가능
(dosync
  (when (= @status :running)
    (ref-set status :completed)))

@status  ; => :completed

(def total-requests (ref 0))

; 여러 스레드에서 동시에 카운터 증가
(defn handle-request []
  (dosync
    (commute total-requests inc))  ; alter 대신 commute 사용
  ; ... 요청 처리 로직 ...
  )

; commute는 교환법칙이 성립하는 연산에 사용
; (+ 1 2 3) = (+ 3 2 1) 처럼 순서가 바뀌어도 결과가 같을 때

(def inventory (ref 100))
(def reserved (ref 0))

(defn reserve-items [amount]
  (dosync
    (ensure inventory)  ; inventory 값이 변경되지 않음을 보장
    (when (>= @inventory amount)
      (alter reserved + amount)
      true)))

; ensure는 읽기만 하는 Ref도 트랜잭션 검증에 포함시킴

; 상품 정보 구조
(defrecord Product [id name price stock])

; 주문 정보 구조
(defrecord Order [id customer-id items total status])

; 상품 재고를 Ref로 관리
(def products 
  (ref {1 (->Product 1 "노트북" 1500000 10)
        2 (->Product 2 "마우스" 30000 50)
        3 (->Product 3 "키보드" 80000 30)}))

; 주문 목록
(def orders (ref []))

; 주문 ID 생성기
(def order-id-counter (ref 0))

; 상품 주문 함수
(defn place-order [customer-id items-to-order]
  (dosync
    (let [order-id (alter order-id-counter inc)
          current-products @products
          
          ; 재고 확인
          stock-check (every? 
                        (fn [[product-id quantity]]
                          (>= (get-in current-products 
                                      [product-id :stock]) 
                              quantity))
                        items-to-order)]
      
      (if stock-check
        ; 재고가 충분하면 주문 처리
        (do
          ; 재고 감소
          (doseq [[product-id quantity] items-to-order]
            (alter products 
                   update-in [product-id :stock] 
                   - quantity))
          
          ; 총액 계산
          (let [total (reduce 
                        (fn [sum [product-id quantity]]
                          (+ sum 
                             (* quantity 
                                (get-in current-products 
                                        [product-id :price]))))
                        0
                        items-to-order)
                
                new-order (->Order order-id 
                                   customer-id 
                                   items-to-order 
                                   total 
                                   :confirmed)]
            
            ; 주문 목록에 추가
            (alter orders conj new-order)
            {:success true 
             :order new-order 
             :message "주문이 완료되었습니다!"}))
        
        ; 재고 부족
        {:success false 
         :message "재고가 부족합니다."}))))

; 주문 취소 함수
(defn cancel-order [order-id]
  (dosync
    (let [order (first (filter #(= (:id %) order-id) @orders))]
      (if (and order (= (:status order) :confirmed))
        (do
          ; 재고 복구
          (doseq [[product-id quantity] (:items order)]
            (alter products 
                   update-in [product-id :stock] 
                   + quantity))
          
          ; 주문 상태 변경
          (alter orders 
                 (fn [order-list]
                   (mapv #(if (= (:id %) order-id)
                           (assoc % :status :cancelled)
                           %)
                         order-list)))
          
          {:success true 
           :message "주문이 취소되었습니다."})
        
        {:success false 
         :message "취소할 수 없는 주문입니다."}))))

; 재고 조회
(defn get-stock [product-id]
  (get-in @products [product-id :stock]))

; 사용 예제
(place-order 1001 {1 2, 2 3})  
; => {:success true, :order {...}, :message "주문이 완료되었습니다!"}

(get-stock 1)  ; => 8 (10에서 2개 감소)
(get-stock 2)  ; => 47 (50에서 3개 감소)

; 동시 주문 시뮬레이션
(defn stress-test-orders []
  (let [threads (repeatedly 50
                  #(Thread. 
                    (fn []
                      (dotimes [_ 10]
                        (place-order 
                          (rand-int 1000)
                          {(inc (rand-int 3)) 1})))))]
    (doseq [t threads] (.start t))
    (doseq [t threads] (.join t))))

(stress-test-orders)
; 500개의 동시 주문이 완벽하게 처리됨!