;; Petrol Panic Buying Simulation
;; Extended from panic buying model by Steve D'Allessandro and Hume Winzar
;; Adaptation for petrol/fuel context

globals
[
  initial-mean-stock  ;; at startup - average fuel perceptions of all agents
  mean_stock          ;; at each iteration - average fuel perceptions of all agents
  mean_price          ;; average petrol price across stations
  decay               ;; a vector of decay coefficients: if memory slider = 5 then decay = [ 1 2 3 4 5 ]
  decay-vector        ;; for rescaling the memory decay values
  daily-consumption   ;; daily fuel consumption rate across all vehicles
  reserve-days        ;; current reserves expressed in days of supply
  initial-reserve-days ;; starting reserve level in days
  
  ;; Media influence
  ticks-since-broadcast  ;; time since last news broadcast
  total-broadcasts       ;; count of news broadcasts triggered
  
  ;; Queue tracking
  total-queue-length     ;; sum of all queue lengths across stations
  avg-queue-length       ;; average queue length per station
  
  ;; Government interventions
  purchase-limit-active?    ;; whether purchase limits are in effect
  price-control-active?     ;; whether price controls are active
  coordinated-messaging?    ;; whether gov messaging is reducing panic
  reserves-released         ;; total reserve days released by government
  
  ;; Data recording
  historical-data        ;; list of data records for export
  
  ;; World market dynamics
  world-market-price-factor  ;; current global market price multiplier
]

breed [station-markers station-marker]  ;; visual markers for petrol stations

turtles-own
[
  panicked?           ;; if true, the car/driver is panicked
  stock-perception    ;; average of fuel in surrounding stations
  price-perception    ;; average price perception
  stock-memory        ;; a list record of last few stock levels
  weighted-memory     ;; a vector of length memory: most recent stock perceptions have greater salience
  sum-weighted-memory ;; a single score: the sum of weighted-memory
  fuel-tank           ;; current fuel level in tank (0-100%)
  fuel-consumption    ;; rate of fuel consumption per tick
  price-sensitivity   ;; how sensitive driver is to price changes
  in-queue?           ;; whether car is currently waiting in queue
  queue-time          ;; how long car has been in queue
]

patches-own
[
  stock               ;; available petrol for purchase (in litres)
  stock-order         ;; usual resupply brings stock up to usual level
  base-price          ;; base price per litre
  current-price       ;; current price (affected by reserves and demand)
  is-station?         ;; whether this patch is a petrol station
  queue-length        ;; number of cars waiting at this station
]

to setup
  clear-all
  setup-memory
  setup-patches
  setup-reserves
  initialize-interventions
  update-patches
  set initial-mean-stock mean [stock] of patches with [is-station?]
  setup-cars
  update-turtles
  reset-ticks
end 

to setup-memory
  set decay n-values memory [ i -> i + 1 ]                      ;; creates a vector of values 1 thru size of memory
  set decay-vector n-values memory [ i -> ( reduce + decay ) ]  ;; a vector of length memory all with the same value
end 

to setup-reserves
  set initial-reserve-days national-reserve-days
  set reserve-days national-reserve-days
  set daily-consumption 0
end 

to setup-cars
  set-default-shape turtles "car"
  create-turtles number-of-cars
  [ setxy (random-xcor * 0.95) (random-ycor * 0.95) ;; spread cars randomly
    set panicked? false
    set color blue
    set stock-memory ( list ( initial-mean-stock ) )
    repeat ( memory - 1 ) [ set stock-memory lput initial-mean-stock stock-memory  ]
    set fuel-tank 50 + random 50  ;; start with 50-100% fuel
    set fuel-consumption 1 + random 2  ;; consume 1-3% per tick
    set price-sensitivity 0.5 + random-float 0.5  ;; sensitivity 0.5-1.0
    set in-queue? false
    set queue-time 0
  ]
  ask n-of initial-panic-size turtles with [breed != station-markers]
    [ become-panicked ]
  update-turtles
end 

to setup-patches
  ask patches
  [ set is-station? false
    set stock 0
    set pcolor green - 2  ;; road color
    set queue-length 0
  ]
  ;; Create petrol stations (fewer, larger stock areas)
  ask n-of petrol-stations patches
  [ set is-station? true
    set stock (initial-stock-per-station + random 50)
    set stock-order stock
    set base-price (average-startup-price - 0.15) + random-float 0.30  ;; base price varies ±15 cents around average
    set current-price base-price
    set pcolor scale-color orange stock 0 (initial-stock-per-station * 2)
    set queue-length 0
    ;; Create visual station marker
    sprout-station-markers 1
    [ set shape "petrol-pump"
      set color yellow
      set size 2.5
    ]
  ]
end 

to go
  if ticks >= max-days
    [ stop ]
  
  ;; Stop if reserves reach zero (if switch is on)
  if stop-at-zero-reserves and reserve-days <= 0
    [ print (word "Simulation stopped: Reserves depleted at day " ticks)
      stop ]

  set ticks-since-broadcast ticks-since-broadcast + 1
  update-world-market-prices
  update-reserves
  update-patches
  update-turtles
  consume-fuel
  update-queues
  resupply
  spread-panic
  record-data  ;; Record data each tick for export
  tick
end 

to record-data
  ;; Record current state for later export
  let panic-pct (count turtles with [breed != station-markers and panicked?] / number-of-cars * 100)
  let data-row (list ticks panic-pct mean_stock reserve-days mean_price avg-queue-length 
                     total-broadcasts purchase-limit-active? price-control-active? coordinated-messaging?)
  set historical-data lput data-row historical-data
end 

to update-world-market-prices
  ;; Simulate random world market price fluctuations
  ;; Price factor fluctuates randomly based on world-market-volatility slider
  let volatility-strength (world-market-volatility / 100)
  let random-change (random-float 0.02 - 0.01) * volatility-strength  ;; ±1% change scaled by volatility
  set world-market-price-factor world-market-price-factor + random-change
  
  ;; Keep price factor in reasonable bounds (0.7 to 1.5 = -30% to +50%)
  if world-market-price-factor < 0.7 [ set world-market-price-factor 0.7 ]
  if world-market-price-factor > 1.5 [ set world-market-price-factor 1.5 ]
end 

to become-panicked  ;; turtle procedure
  set panicked? true
  set color red
  set size 1.5  ;; panicked cars appear larger
end 

to initialize-interventions
  set ticks-since-broadcast 0
  set total-broadcasts 0
  set total-queue-length 0
  set avg-queue-length 0
  set purchase-limit-active? false
  set price-control-active? false
  set coordinated-messaging? false
  set reserves-released 0
  set historical-data []  ;; empty list to start
  set world-market-price-factor 1.0  ;; start at neutral (1.0 = no change)
end 

to news-broadcast
  ;; Simulate a breaking news event that triggers panic
  set total-broadcasts total-broadcasts + 1
  set ticks-since-broadcast 0
  
  ;; News affects a percentage of calm drivers based on media-influence-strength
  let affected-count floor (media-influence-strength * count turtles with [breed != station-markers and not panicked?] / 100)
  ask n-of affected-count turtles with [breed != station-markers and not panicked?]
  [ become-panicked ]
end 

to update-queues
  ;; Update queue lengths at each station
  ask patches with [is-station?]
  [ set queue-length count turtles with [breed != station-markers and in-queue?] in-radius 2 ]
  
  ;; Calculate global queue statistics
  set total-queue-length sum [queue-length] of patches with [is-station?]
  ifelse petrol-stations > 0
  [ set avg-queue-length total-queue-length / petrol-stations ]
  [ set avg-queue-length 0 ]
  
  ;; Cars in queues trigger panic in observers
  if queues-trigger-panic = true
  [ ask turtles with [breed != station-markers and not panicked?]
    [ let nearby-queue-length sum [queue-length] of patches with [is-station?] in-radius 5
      if nearby-queue-length > 3  ;; seeing 3+ cars queued triggers panic
      [ if random 100 < 10  ;; 10% chance per tick when seeing queues
        [ become-panicked ]
      ]
    ]
  ]
end 

to release-strategic-reserves
  ;; Government releases strategic reserves (uses stored fuel to supply the market)
  ;; Decreases reserve-days but adds stock to stations
  
  let release-amount reserve-release-days
  
  ifelse reserve-days >= release-amount
  [ ;; Have enough reserves to release
    set reserve-days reserve-days - release-amount  ;; Decrease stored reserves
    set reserves-released reserves-released + release-amount
    
    ;; Add the released fuel to market (distribute to stations)
    let fuel-per-station (release-amount * initial-stock-per-station / petrol-stations)
    ask patches with [is-station?]
    [ set stock stock + fuel-per-station
      ;; Cap at maximum stock level
      if stock > (stock-order * 1.5) [ set stock (stock-order * 1.5) ]
    ]
    
    print (word "Released " release-amount " days of reserves to market. Reserves now: " reserve-days " days")
  ]
  [ ;; Not enough reserves to release full amount
    if reserve-days > 0
    [ let actual-release reserve-days
      let fuel-per-station (actual-release * initial-stock-per-station / petrol-stations)
      ask patches with [is-station?]
      [ set stock stock + fuel-per-station
        if stock > (stock-order * 1.5) [ set stock (stock-order * 1.5) ]
      ]
      set reserves-released reserves-released + actual-release
      set reserve-days 0
      print (word "Released all remaining reserves (" actual-release " days). Reserves now: 0 days")
    ]
    if reserve-days <= 0
    [ print "Cannot release: No reserves remaining!" ]
  ]
end 

to implement-purchase-limits
  ;; Toggle purchase limits on/off
  set purchase-limit-active? not purchase-limit-active?
end 

to implement-price-controls
  ;; Toggle price controls on/off
  set price-control-active? not price-control-active?
  
  if price-control-active?
  [ ;; Freeze prices at current base prices
    ask patches with [is-station?]
    [ set current-price base-price ]
  ]
end 

to coordinated-gov-messaging
  ;; Government coordinated messaging reduces panic contagion
  set coordinated-messaging? not coordinated-messaging?
end 

to export-data
  ;; NOTE: File export only works in NetLogo Desktop, not in web version
  ;; In desktop version, this exports all historical simulation data to CSV file
  ;; For web version, data is still recorded and visible in plots/monitors
  
  print (word "Data recording active: " length historical-data " days recorded")
  print "Note: CSV export only available in NetLogo Desktop version"
  print "Download the .nlogo file to use export feature locally"
end 

to update-reserves
  ;; Calculate daily consumption rate (total fuel consumed per day)
  set daily-consumption sum [fuel-consumption] of turtles with [breed != station-markers]
  
  ;; Reserves deplete based on overall demand and panic level
  let panic-multiplier 1 + (count turtles with [breed != station-markers and panicked?] / number-of-cars)
  let reserve-depletion (daily-consumption * panic-multiplier) / (initial-stock-per-station * petrol-stations)
  
  ;; Update reserve days (depletes faster when panic buying occurs)
  set reserve-days reserve-days - reserve-depletion
  if reserve-days < 0 [ set reserve-days 0 ]
  
  ;; Price calculation: combines reserve-based changes + world market fluctuations
  if price-control-active? = false
  [ ;; Calculate reserve-based price multiplier
    let reserve-multiplier 1.0
    if reserve-days < (initial-reserve-days * 0.3)
    [ set reserve-multiplier (1 + ((initial-reserve-days - reserve-days) / initial-reserve-days) * price-volatility) ]
    
    ;; Apply both world market factor and reserve multiplier
    ask patches with [is-station?]
    [ set current-price base-price * world-market-price-factor * reserve-multiplier ]
  ]
end 

to spread-panic
  if shortage-makes-panic = true
  [ ask turtles with [breed != station-markers]
    [
      ifelse memory-moderates-panic = true
        [ set weighted-memory  ( map * stock-memory  decay)
          set weighted-memory  ( map / weighted-memory  decay-vector )
          set sum-weighted-memory reduce + weighted-memory
          if sum-weighted-memory <  ( initial-mean-stock * (( random randomness) / 100 ))
          [ become-panicked ]
        ]
        [ if stock-perception <  ( initial-mean-stock * (( random randomness) / 100 ))
          [ become-panicked ]
        ]
    ]
  ]
  
  ;; Price panic - high prices can trigger panic
  if price-triggers-panic = true
  [ ask turtles with [breed != station-markers]
    [ if price-perception > (mean_price * 1.2 * price-sensitivity)
      [ become-panicked ]
    ]
  ]
  
  ;; Reserves panic - awareness of low national reserves (measured in days)
  if reserves-trigger-panic = true
  [ if reserve-days < (initial-reserve-days * reserves-panic-threshold / 100)
    [ ask turtles with [breed != station-markers]
      [ if random 100 < 5  ;; 5% chance per tick when reserves low
        [ become-panicked ]
      ]
    ]
  ]
  
  if panic-makes-panic = true
  [ ;; Coordinated messaging reduces panic contagion rate by 50%
    let effective-contagion-rate panic-contagion-rate
    if coordinated-messaging? = true
    [ set effective-contagion-rate panic-contagion-rate * 0.5 ]
    
    ask turtles with [breed != station-markers and panicked?]
    [ ask turtles with [breed != station-markers] in-radius communication-radius
        [ if random 100 < effective-contagion-rate
            [ become-panicked ]
        ]
    ]
  ]
end 

to consume-fuel
  ask turtles with [breed != station-markers]
  [ set fuel-tank fuel-tank - fuel-consumption
    ;; Cars with very low fuel become panicked
    if fuel-tank < 20 and not panicked?
    [ if random 100 < 30
      [ become-panicked ]
    ]
    ;; Refuel tank if possible
    if fuel-tank < 100
    [ let available-fuel [stock] of patch-here
      ifelse available-fuel > 0
      [ let fuel-needed min (list (100 - fuel-tank) available-fuel)
        set fuel-tank fuel-tank + fuel-needed
        ask patch-here
        [ if is-station?
          [ set stock stock - fuel-needed ]
        ]
      ]
      [ ;; No fuel at current location, move towards nearest station
        let nearest-station min-one-of patches with [is-station? and stock > 0] [distance myself]
        if nearest-station != nobody
        [ face nearest-station
          forward 1
        ]
      ]
    ]
  ]
end 

to resupply
  if ticks mod restock-rate = 0
  [ ask patches with [is-station?]
    [ ;; Resupply depends on national reserves (days available)
      let supply-multiplier min (list 1.0 (reserve-days / initial-reserve-days))
      set stock stock + (stock-order * supply-multiplier * 0.5)
      if stock > stock-order [ set stock stock-order ]
      set pcolor scale-color orange stock 0 (initial-stock-per-station * 2)
    ]
  ]
end 

to update-patches
  set mean_stock mean [stock] of patches with [is-station?]
  set mean_price mean [current-price] of patches with [is-station?]
  ask patches with [is-station?]
  [ set pcolor scale-color orange stock 0 (initial-stock-per-station * 2) ]
end 

to update-turtles
  ask turtles with [breed != station-markers]
  [
    ;; Move if no fuel at current location
    if ( [stock] of patch-here <= 0 ) or ( not [is-station?] of patch-here )
      [ set heading random 360
        forward 1
      ]
      
    ;; Update perceptions
    let nearby-stations patches with [is-station?] in-radius stock-perception-radius
    ifelse any? nearby-stations
    [ set stock-perception mean [stock] of nearby-stations
      set price-perception mean [current-price] of nearby-stations
    ]
    [ set stock-perception 0
      set price-perception mean_price
    ]
    
    set stock-memory lput stock-perception stock-memory
    if length stock-memory > memory
    [ set stock-memory remove-item 0 stock-memory ]
  ]

  ;; Update queue status
  ask turtles with [breed != station-markers]
  [ ifelse [is-station?] of patch-here and fuel-tank < 90
    [ set in-queue? true
      set queue-time queue-time + 1 ]
    [ set in-queue? false
      set queue-time 0 ]
  ]

  ;; Regular (non-panicked) cars buy normal amounts
  ask turtles with [breed != station-markers and not panicked?]
  [ if fuel-tank < 80  ;; refuel if below 80%
    [ let purchase-amount 20
      if purchase-limit-active? [ set purchase-amount min (list 20 purchase-limit-amount) ]
      
      ask patch-here
      [ if is-station? and stock >= purchase-amount
        [ set stock ( stock - purchase-amount) ]
      ]
    ]
  ]
  
  ;; Panicked cars try to fill up completely and hoard
  ask turtles with [breed != station-markers and panicked?]
  [ ifelse panic-hoarding = true
    [ ;; Buy out all fuel at current station and neighbors (unless limits active)
      ifelse purchase-limit-active?
      [ ;; With limits, can only buy limited amount
        let purchase-amount purchase-limit-amount
        ask patch-here
        [ if is-station?
          [ set stock max (list 0 (stock - purchase-amount)) ]
        ]
      ]
      [ ;; Without limits, buy everything
        ask patch-here
        [ if is-station?
          [ ask neighbors with [is-station?]
            [ set stock 0 ]
            set stock 0
          ]
        ]
      ]
    ]
    [ ;; Just buy maximum at current station
      let panic-purchase 60
      if purchase-limit-active? [ set panic-purchase min (list 60 purchase-limit-amount) ]
      
      ask patch-here
      [ if is-station?
        [ set stock max (list 0 (stock - panic-purchase)) ]
      ]
    ]
  ]
end