Options

import android.net.Uri
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import ly.img.engine.Engine
import ly.img.engine.ExportOptions
import ly.img.engine.MimeType
import ly.img.engine.addDefaultAssetSources
import java.io.File
import java.util.UUID

fun exportingBlocks(
    license: String,
    userId: String,
) = CoroutineScope(Dispatchers.Main).launch {
    val engine = Engine.getInstance(id = "ly.img.engine.example")
    engine.start(license = license, userId = userId)
    engine.bindOffscreen(width = 1080, height = 1920)
    engine.scene.create()
    engine.editor.setSettingString(
        "basePath",
        value = "https://cdn.img.ly/packages/imgly/cesdk-engine/1.23.0/assets",
    )
    engine.addDefaultAssetSources()

    val sceneUri = Uri.parse(
        "https://cdn.img.ly/assets/demo/v1/ly.img.template/templates/cesdk_postcard_1.scene",
    )
    val scene = engine.scene.load(sceneUri = sceneUri)

    // Export scene as PNG image.
    val mimeType = MimeType.PNG
    // Optionally, the maximum supported export size can be checked before exporting.
    val maxExportSizeInPixels = engine.editor.getMaxExportSize()
    // Optionally, the compression level and the target size can be specified.
    val options = ExportOptions(pngCompressionLevel = 9, targetWidth = null, targetHeight = null)
    val blob = engine.block.export(scene, mimeType = mimeType, options = options)

    // Save the blob to file
    withContext(Dispatchers.IO) {
        File.createTempFile(UUID.randomUUID().toString(), ".png").apply {
            outputStream().channel.write(blob)
        }
    }

    engine.stop()
}

val scene = engine.scene.get()!!
val page = engine.scene.getCurrentPage()!!

val exportOptions = options = ExportOptions(
    /**
     * The PNG compression level to use, when exporting to PNG.
     * Valid values are 0 to 9, higher means smaller, but slower.
     * Quality is not affected.
     * Ignored for other encodings.
     * The default value is 5.
     */
    pngCompressionLevel = 5,
    /**
     * The JPEG quality to use when encoding to JPEG.
     * Valid values are (0F-1F], higher means better quality.
     * Ignored for other encodings.
     * The default value is 0.9F.
     */
    jpegQuality = 0.9F,
    /**
     * The WebP quality to use when encoding to WebP. Valid values are (0-1], higher means better quality.
     * WebP uses a special lossless encoding that usually produces smaller file sizes than PNG.
     * Ignored for other encodings. Defaults to 1.0.
     */
    webpQuality = 1.0F,
    /**
     * An optional target width used in conjunction with target height.
     * If used, the block will be rendered large enough, that it fills the target
     * size entirely while maintaining its aspect ratio.
     * The default value is null.
     */
    targetWidth = null,
    /**
     * An optional target height used in conjunction with target with.
     * If used, the block will be rendered large enough, that it fills the target
     * size entirely while maintaining its aspect ratio.
     * The default value is null.
     */
    targetHeight = null,
    /**
     * Export the PDF document with a higher compatibility to different PDF viewers.
     * Bitmap images and some effects like gradients will be rasterized with the DPI
     * setting instead of embedding them directly.
     * The default value is true.
     */
    exportPdfWithHighCompatibility = true,
    /**
    * Export the PDF document with an underlayer.
    * An underlayer is generated by adding a graphics block behind the existing elements of the shape of the elements on
    * the page.
    */
    exportPdfWithUnderlayer = false,
    /**
    * The name of the spot color to be used for the underlayer's fill.
    */
    underlayerSpotColorName = ""
    /**
    * The adjustment in size of the shape of the underlayer.
    */
    underlayerOffset = 0.0F
)
val blob = engine.block.export(
    block = scene,
    mimeType = MimeType.PNG,
    options = exportOptions
)

val colorMaskedBlob = engine.block.exportWithColorMask(
    block = scene,
    mimeType = MimeType.PNG,
    maskColor = Color.fromRGBA(r = 1F, g = 0F, b = 0F)
    options = exportOptions
)

val videoExportOptions = ExportVideoOptions(
  /**
   * Determines the encoder feature set and in turn the quality, size and speed of the encoding process.
   * The default value is 77 (Main Profile).
   */
  h264Profile = 77,
  /**
   * Controls the H.264 encoding level. This relates to parameters used by the encoder such as bit rate,
   * timings and motion vectors. Defined by the spec are levels 1.0 up to 6.2. To arrive at an integer value,
   * the level is multiplied by ten. E.g. to get level 5.2, pass a value of 52.
   * The default value is 52.
   */
  h264Level = 52,
  /**
   * The video bitrate in bits per second. The maximum bitrate is determined by h264Profile and h264Level.
   * If the value is 0, the bitrate is automatically determined by the engine.
   */
  videoBitrate = 0,
  /**
   * The audio bitrate in bits per second. If the value is 0, the bitrate is automatically determined by the engine (128kbps for stereo AAC stream).
   */
  audioBitrate = 0,
  /**
   * The target frame rate of the exported video in Hz.
   * The default value is 30.
    */
  frameRate = 30.0F,
  /**
   * An optional target width used in conjunction with target height.
   * If used, the block will be rendered large enough, that it fills the target
   * size entirely while maintaining its aspect ratio.
   */
  targetWidth = 1280,
  /**
   * An optional target height used in conjunction with target width.
   * If used, the block will be rendered large enough, that it fills the target
   * size entirely while maintaining its aspect ratio.
   */
  targetHeight = 720
)
val videoBlob = engine.block.exportVideo(
    block = page,
    timeOffset = 0.0,
    duration = engine.block.getDuration(page),
    mimeType = MimeType.MP4,
    progressCallback = {
        println("Rendered ${it.renderedFrames} frames and encoded ${it.encodedFrames} frames out of ${it.totalFrames} frames")
    }
)

val maxExportSizeInPixels = engine.editor.getMaxExportSize()

val availableMemoryInBytes = engine.editor.getAvailableMemory()

suspend fun export(
    block: DesignBlock,
    mimeType: MimeType,
    options: ExportOptions? = null,
    onPreExport: suspend Engine.() -> Unit = {},
): ByteBuffer

suspend fun exportWithColorMask(
    block: DesignBlock,
    mimeType: MimeType,
    maskColor: RGBAColor,
    options: ExportOptions? = null,
    onPreExport: suspend Engine.() -> Unit = {},
): Pair<ByteBuffer, ByteBuffer>

suspend fun exportVideo(
    block: DesignBlock,
    timeOffset: Double,
    duration: Double,
    mimeType: MimeType,
    progressCallback: (ExportVideoProgress) -> Unit,
    options: ExportVideoOptions? = null,
    onPreExport: suspend Engine.() -> Unit = {},
): ByteBuffer

fun getMaxExportSize(): Int

fun getAvailableMemory(): Long