chain-source

;; title: source
;; version:
;; summary:
;; description:
(define-constant ERR-NOT-AUTHORIZED (err u100))
(define-constant ERR-INVALID-ROLE (err u101))
(define-constant ERR-NOT-FOUND (err u102))
(define-constant ERR-INVALID-INPUT (err u103))
(define-constant ERR-ALREADY-EXISTS (err u104))

;; traits
;;
(define-data-var contract-owner principal tx-sender)

;; token definitions
;;
(define-constant MANUFACTURER u"manufacturer")
(define-constant TRANSPORTER u"transporter")
(define-constant RETAILER u"retailer")
(define-constant MIN-STRING-LENGTH u1)
(define-constant MAX-STRING-LENGTH-100 u100)
(define-constant MAX-STRING-LENGTH-50 u50)

;; constants
;;
(define-map roles principal 
  {
    role: (string-utf8 20),
    is-active: bool
  }
)

;; data vars
;;
(define-map products uint 
  { 
    id: uint,
    name: (string-utf8 100),
    manufacturer: principal,
    origin: (string-utf8 50),
    timestamp: uint,
    current-location: (string-utf8 100),
    status: (string-utf8 20)
  }
)

;; data maps
;;
;; New map for product history
(define-map product-history 
  {product-id: uint, change-id: uint} 
  { 
    timestamp: uint,
    location: (string-utf8 100),
    status: (string-utf8 20)
  }
)

;; public functions
;;
(define-data-var product-counter uint u0)
(define-data-var change-counter uint u0) ;; To track the number of changes for history

;; read only functions
;;
(define-private (is-valid-role (role (string-utf8 20)))
  (or 
    (is-eq role MANUFACTURER)
    (is-eq role TRANSPORTER)
    (is-eq role RETAILER)
  )
)

;; private functions
;;
(define-private (is-valid-string-length (str (string-utf8 100)) (max-len uint))
  (and 
    (>= (len str) MIN-STRING-LENGTH)
    (<= (len str) max-len)
  )
)

(define-private (validate-strings 
    (name (string-utf8 100))
    (origin (string-utf8 50))
    (location (string-utf8 100)))
  (and 
    (is-valid-string-length name MAX-STRING-LENGTH-100)
    (is-valid-string-length origin MAX-STRING-LENGTH-50)
    (is-valid-string-length location MAX-STRING-LENGTH-100)
  )
)

(define-private (is-contract-owner)
  (is-eq tx-sender (var-get contract-owner))
)

(define-private (check-role (address principal) (required-role (string-utf8 20)))
  (match (map-get? roles address)
    role (and 
          (is-eq (get role role) required-role)
          (get is-active role))
    false
  )
)

(define-private (safe-get-role (address principal))
  (default-to 
    { role: u"", is-active: false }
    (map-get? roles address)
  )
)

(define-public (assign-role (address principal) (new-role (string-utf8 20)))
  (let ((current-role (safe-get-role address)))
    (begin
      (asserts! (is-contract-owner) ERR-NOT-AUTHORIZED)
      (asserts! (is-valid-role new-role) ERR-INVALID-INPUT)
      (asserts! (not (get is-active current-role)) ERR-ALREADY-EXISTS)
      (ok (map-set roles address { 
        role: new-role, 
        is-active: true 
      }))
    )
  )
)






(define-public (revoke-role (address principal))
  (let ((current-role (safe-get-role address)))
    (begin
      (asserts! (is-contract-owner) ERR-NOT-AUTHORIZED)
      (asserts! (get is-active current-role) ERR-NOT-FOUND)
      (ok (map-set roles address { 
        role: u"", 
        is-active: false 
      }))
    )
  )
)

(define-private (safe-get-product (product-id uint))
  (map-get? products product-id)
)

(define-public (add-product 
    (name (string-utf8 100)) 
    (origin (string-utf8 50)) 
    (location (string-utf8 100)))
  (let 
    (
      (safe-id (var-get product-counter))
      (existing-product (safe-get-product safe-id))
      (validated-strings (validate-strings name origin location))
    )
    (begin
      (asserts! (check-role tx-sender MANUFACTURER) ERR-NOT-AUTHORIZED)
      (asserts! validated-strings ERR-INVALID-INPUT)
      (asserts! (is-none existing-product) ERR-ALREADY-EXISTS)
      (map-set products safe-id
        {
          id: safe-id,
          name: name,
          manufacturer: tx-sender,
          origin: origin,
          timestamp: stacks-block-height,
          current-location: location,
          status: u"created"
        })
      (var-set product-counter (+ safe-id u1))
      (ok safe-id)
    )
  )
)

;; Update location and add history entry
(define-public (update-location 
    (product-id uint) 
    (new-location (string-utf8 100)))
  (let (
      (product (safe-get-product product-id))
      (valid-location (is-valid-string-length new-location MAX-STRING-LENGTH-100))
      (change-id (var-get change-counter))
    )
    (begin
      (asserts! (or 
        (check-role tx-sender TRANSPORTER)
        (check-role tx-sender MANUFACTURER)) ERR-NOT-AUTHORIZED)
      (asserts! valid-location ERR-INVALID-INPUT)
      (asserts! (is-some product) ERR-NOT-FOUND)
      ;; Update the product with the new location
      (map-set products product-id
        (merge (unwrap! product ERR-NOT-FOUND)
          { current-location: new-location }))
      ;; Add a new entry to the product history
      (map-set product-history {product-id: product-id, change-id: change-id}
        {
          timestamp: stacks-block-height,
          location: new-location,
          status: (get status (unwrap! product ERR-NOT-FOUND))
        })
      ;; Increment the change counter
      (var-set change-counter (+ change-id u1))
      (ok change-id)
    )
  )
)

;; New function to get the product's history
(define-read-only (get-product-history (product-id uint))
  (map-get? product-history {product-id: product-id, change-id: u0})
)

(define-read-only (get-product (product-id uint))
  (safe-get-product product-id)
)

(define-read-only (get-role (address principal))
  (safe-get-role address)
)