tpl := import("@platforma-sdk/workflow-tengo:tpl.light")
ll := import("@platforma-sdk/workflow-tengo:ll")
wdSave := import("@platforma-sdk/workflow-tengo:workdir.save")


tpl.defineOutputs(["result", "workdir"])

proc := func() {
	self := undefined

	self = {

		_wdBefore: undefined,



		wdBefore: func() {
			if is_undefined(self._wdBefore) {
				self._wdBefore = tpl.inputs().workdir
			}
			return self._wdBefore
		},

		_filesInWd: undefined,



		filesInWd: func() {
			if is_undefined(self._filesInWd) {
				self._filesInWd = self.wdBefore().getDataAsJson().files
			}

			return self._filesInWd
		},

		_wdAfterReadFiles: undefined,



		wdAfterReadFiles: func() {
			if is_undefined(self._wdAfterReadFiles) {

				if !is_undefined(tpl.inputs().wdAfterReadFiles) {





					self._wdAfterReadFiles = tpl.inputs().wdAfterReadFiles
				} else {


					self._wdAfterReadFiles = self.wdBefore()
				}
			}

			return self._wdAfterReadFiles
		},








		readFiles: func(cb) {
			tpl.prepare(func(inputs){
				inputs.files = self.filesInWd()

				files := cb(inputs)

				wdBuilder := wdSave.builder(self.wdBefore())
				for _, fName in files {
					wdBuilder.saveFileContent(fName)
				}
				wd := wdBuilder.build()


				preps := {}
				for key, fName in files {
					preps[key] = wd.getSavedFileContent(fName)
				}

				preps.wdAfterReadFiles = wd.getWorkdirAfter()

				return preps
			})
		},

		_wdFinalBuilder: undefined,



		wdFinalBuilder: func() {
			if is_undefined(self._wdFinalBuilder) {
				self._wdFinalBuilder = wdSave.builder(self.wdAfterReadFiles())
			}
			return self._wdFinalBuilder
		},






		saveFile: func(fName) {
			self.wdFinalBuilder().saveFile(fName)
			return self.wdFinalBuilder().getSavedFile(fName)
		},






		saveFileContent: func(fName) {
			self.wdFinalBuilder().saveFileContent(fName)
			return self.wdFinalBuilder().getSavedFileContent(fName)
		},









		body: func(cb) {
			tpl.body(func(inputs) {

				inputs.files = self.filesInWd()
				result := cb(inputs)
				wd := self.wdFinalBuilder().build()

				return {
					result: result,
					workdir: wd.getWorkdirAfter()
				}
			})
		}
	}

	return ll.toStrict(self)
}


instance := proc()

export ll.toStrict({
	readFiles: instance.readFiles,
	saveFile: instance.saveFile,
	saveFileContent: instance.saveFileContent,
	body: instance.body
})