{.warning[UnusedImport]: off.}

import pixie, json, times, strformat, strutils, sequtils, options, algorithm

import std/monotimes

import frameos/values

import frameos/types

import frameos/channels

import frameos/utils/image

import frameos/utils/url

import frameos/utils/time

import apps/render/image/app as render_imageApp

import apps/data/localImage/app as data_localImageApp

import apps/render/text/app as render_textApp

const DEBUG = false

let PUBLIC_STATE_FIELDS*: seq[StateField] = @[]

let PERSISTED_STATE_KEYS*: seq[string] = @[]

type Scene* = ref object of FrameScene

node1: render_imageApp.App

node2: data_localImageApp.App

node3: render_textApp.App

{.push hint[XDeclaredButNotUsed]: off.}

var cache0: Option[Image] = none(Image)

var cache0Time: float = 0

proc runNode*(self: Scene, nodeId: NodeId, context: ExecutionContext, asDataNode = false): Value =

result = VNone()

let scene = self

let frameConfig = scene.frameConfig

let state = scene.state

var nextNode = nodeId

var currentNode = nodeId

var timer = epochTime()

while nextNode != -1.NodeId:

currentNode = nextNode

timer = epochTime()

case nextNode:

of 1.NodeId: # render/image

self.node1.appConfig.image = block:

if cache0.isNone() or epochTime() > cache0Time + 900.0:

cache0 = some(block:

self.node2.get(context))

cache0Time = epochTime()

cache0.get()

self.node1.run(context)

nextNode = 3.NodeId

of 3.NodeId: # render/text

self.node3.run(context)

nextNode = -1.NodeId

else:

nextNode = -1.NodeId

if DEBUG:

self.logger.log(%*{"event": "debug:scene", "node": currentNode, "ms": (-timer + epochTime()) * 1000})

proc runEvent*(self: Scene, context: ExecutionContext) =

case context.event:

of "render":

context.image.fill(Scene(self).backgroundColor)

try: discard self.runNode(1.NodeId, context)

except Exception as e: self.logger.log(%*{"event": "render:error", "node": 1, "error": $e.msg, "stacktrace": e.getStackTrace()})

of "setSceneState":

if context.payload.hasKey("state") and context.payload["state"].kind == JObject:

let payload = context.payload["state"]

for field in PUBLIC_STATE_FIELDS:

let key = field.name

if payload.hasKey(key) and payload[key] != self.state{key}:

self.state[key] = copy(payload[key])

if context.payload.hasKey("render"):

sendEvent("render", %*{})

of "setCurrentScene":

if context.payload.hasKey("state") and context.payload["state"].kind == JObject:

let payload = context.payload["state"]

for field in PUBLIC_STATE_FIELDS:

let key = field.name

if payload.hasKey(key) and payload[key] != self.state{key}:

self.state[key] = copy(payload[key])

else: discard

proc runEvent*(self: FrameScene, context: ExecutionContext) =

runEvent(Scene(self), context)

proc render*(self: FrameScene, context: ExecutionContext): Image =

runEvent(self, context)

return context.image

proc init*(sceneId: SceneId, frameConfig: FrameConfig, logger: Logger, persistedState: JsonNode): FrameScene =

var state = %*{}

if persistedState.kind == JObject:

for key in persistedState.keys:

state[key] = persistedState[key]

let scene = Scene(id: sceneId, frameConfig: frameConfig, state: state, logger: logger, refreshInterval: 300.0, backgroundColor: parseHtmlColor("#000000"))

let self = scene

result = scene

var context = ExecutionContext(scene: scene, event: "init", payload: state, hasImage: false, loopIndex: 0, loopKey: ".")

scene.execNode = (proc(nodeId: NodeId, context: ExecutionContext) = discard scene.runNode(nodeId, context))

scene.getDataNode = (proc(nodeId: NodeId, context: ExecutionContext): Value = scene.getDataNode(nodeId, context))

scene.node1 = render_imageApp.App(nodeName: "render/image", nodeId: 1.NodeId, scene: scene.FrameScene, frameConfig: scene.frameConfig, appConfig: render_imageApp.AppConfig(

inputImage: none(Image),

placement: "cover",

offsetX: 0,

offsetY: 0,

blendMode: "normal",

))

scene.node2 = data_localImageApp.App(nodeName: "data/localImage", nodeId: 2.NodeId, scene: scene.FrameScene, frameConfig: scene.frameConfig, appConfig: data_localImageApp.AppConfig(

path: "./assets/image.png",

order: "random",

counterStateKey: "",

metadataStateKey: "",

search: "",

))

scene.node2.init()

scene.node3 = render_textApp.App(nodeName: "render/text", nodeId: 3.NodeId, scene: scene.FrameScene, frameConfig: scene.frameConfig, appConfig: render_textApp.AppConfig(

text: "Activate proton beam",

inputImage: none(Image),

richText: "disabled",

position: "center",

vAlign: "middle",

offsetX: 0.0,

offsetY: 0.0,

padding: 10.0,

fontColor: parseHtmlColor("#ffffff"),

fontSize: 32.0,

borderColor: parseHtmlColor("#000000"),

borderWidth: 2,

overflow: "fit-bounds",

))

runEvent(self, context)

{.pop.}

var exportedScene* = ExportedScene(

publicStateFields: PUBLIC_STATE_FIELDS,

persistedStateKeys: PERSISTED_STATE_KEYS,

init: init,

runEvent: runEvent,

render: render

)