feature-flags

;; title: feature-flags
;; version:
;; summary:
;; description:

;; traits
;; Lottery Pool Smart Contract

;; Constants
(define-constant CONTRACT_OWNER tx-sender)
(define-constant ERR_NOT_AUTHORIZED (err u100))
(define-constant ERR_LOTTERY_INACTIVE (err u102))
(define-constant ERR_INSUFFICIENT_BALANCE (err u103))
(define-constant ERR_INVALID_TICKET_PRICE (err u104))
(define-constant ERR_NO_WINNERS (err u105))
(define-constant ERR_NO_TICKETS (err u106))
(define-constant ERR_WITHDRAWAL_PERIOD_ENDED (err u107))
(define-constant ERR_LOTTERY_NOT_ENDED (err u108))
(define-constant ERR_WINNERS_ALREADY_SELECTED (err u109))
(define-constant ERR_INVALID_DURATION (err u110))
(define-constant ERR_INVALID_WITHDRAWAL_PERIOD (err u111))
(define-constant ERR_INVALID_WINNER_ID (err u112))

;; Data Variables
(define-data-var is-lottery-active bool false)
(define-data-var current-ticket-price uint u1000000) ;; 1 STX
(define-data-var current-lottery-pot uint u0)
(define-data-var total-tickets-sold uint u0)
(define-data-var number-of-winners uint u1)
(define-data-var lottery-end-block-height uint u0)
(define-data-var withdrawal-end-block-height uint u0)
(define-data-var organizer-fee-percentage uint u5) ;; 5% fee
(define-data-var prize-per-winner uint u0)
(define-data-var winners-selected bool false)

;; Maps
(define-map ticket-ownership {ticket-id: uint} {owner: principal})
(define-map user-ticket-count principal uint)
(define-map winners {winner-id: uint} {address: principal, claimed: bool})

;; Private Functions
(define-private (is-contract-owner)
  (is-eq tx-sender CONTRACT_OWNER))

(define-private (validate-lottery-is-active)
  (if (var-get is-lottery-active)
    (ok true)
    ERR_LOTTERY_INACTIVE))

(define-private (validate-sufficient-balance (required-balance uint))
  (if (>= (stx-get-balance tx-sender) required-balance)
    (ok true)
    ERR_INSUFFICIENT_BALANCE))

(define-private (select-random-winner (random-seed uint) (ticket-id uint))
  (mod (+ random-seed ticket-id) (var-get total-tickets-sold)))

(define-private (calculate-organizer-fee (total-amount uint))
  (/ (* total-amount (var-get organizer-fee-percentage)) u100))

;; Public Functions
(define-public (start-new-lottery (duration-in-blocks uint) (withdrawal-period uint) (ticket-price uint) (winner-count uint) (fee-percentage uint))
  (begin
    (asserts! (is-contract-owner) ERR_NOT_AUTHORIZED)
    (asserts! (> ticket-price u0) ERR_INVALID_TICKET_PRICE)
    (asserts! (> winner-count u0) ERR_NO_WINNERS)
    (asserts! (<= fee-percentage u20) ERR_NOT_AUTHORIZED) ;; Max 20% fee
    (asserts! (not (var-get is-lottery-active)) ERR_NOT_AUTHORIZED)
    (asserts! (> duration-in-blocks u0) ERR_INVALID_DURATION)
    (asserts! (> withdrawal-period u0) ERR_INVALID_WITHDRAWAL_PERIOD)
    (var-set is-lottery-active true)
    (var-set current-ticket-price ticket-price)
    (var-set current-lottery-pot u0)
    (var-set total-tickets-sold u0)
    (var-set number-of-winners winner-count)
    (var-set lottery-end-block-height (+ stacks-block-height duration-in-blocks))
    (var-set withdrawal-end-block-height (+ stacks-block-height withdrawal-period))
    (var-set organizer-fee-percentage fee-percentage)
    (var-set winners-selected false)
    (ok true)))



(define-public (select-winners (random-seed uint))
  (let ((winner-count (var-get number-of-winners))
        (total-ticket-count (var-get total-tickets-sold)))
    (begin
      (asserts! (is-contract-owner) ERR_NOT_AUTHORIZED)
      (asserts! (not (var-get is-lottery-active)) ERR_LOTTERY_INACTIVE)
      (asserts! (not (var-get winners-selected)) ERR_WINNERS_ALREADY_SELECTED)
      (asserts! (> total-ticket-count u0) ERR_NO_WINNERS)
      (var-set winners-selected true)
      (let ((selected-winners (fold select-winner-and-save
                                    (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9)
                                    {random-seed: random-seed, current-winner-id: u0, remaining-winners: winner-count})))
        (ok (get current-winner-id selected-winners))))))

(define-private (select-winner-and-save (index uint) (context {random-seed: uint, current-winner-id: uint, remaining-winners: uint}))
  (if (> (get remaining-winners context) u0)
    (let ((winning-ticket-id (select-random-winner (get random-seed context) index))
          (winner-address (get owner (unwrap-panic (map-get? ticket-ownership {ticket-id: (+ winning-ticket-id u1)})))))
      (begin
        (map-set winners {winner-id: (get current-winner-id context)} {address: winner-address, claimed: false})
        {random-seed: (+ (get random-seed context) u1),
         current-winner-id: (+ (get current-winner-id context) u1),
         remaining-winners: (- (get remaining-winners context) u1)}))
    context))


;; Read-Only Functions
(define-read-only (get-current-ticket-price)
  (ok (var-get current-ticket-price)))

(define-read-only (get-current-lottery-pot)
  (ok (var-get current-lottery-pot)))

(define-read-only (get-user-ticket-count (user-address principal))
  (ok (default-to u0 (map-get? user-ticket-count user-address))))

(define-read-only (get-total-tickets-sold)
  (ok (var-get total-tickets-sold)))

(define-read-only (check-if-lottery-is-active)
  (ok (var-get is-lottery-active)))

(define-read-only (get-lottery-end-block-height)
  (ok (var-get lottery-end-block-height)))

(define-read-only (get-withdrawal-end-block-height)
  (ok (var-get withdrawal-end-block-height)))

(define-read-only (get-organizer-fee-percentage)
  (ok (var-get organizer-fee-percentage)))

(define-read-only (get-winner-info (winner-id uint))
  (ok (map-get? winners {winner-id: winner-id})))

(define-read-only (are-winners-selected)
  (ok (var-get winners-selected)))