/* 
*   VideoKit
*   Copyright © 2026 Yusuf Olokoba. All Rights Reserved.
*/

#nullable enable

namespace VideoKit {

    using AOT;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Runtime.InteropServices;
    using System.Runtime.Serialization;
    using System.Text;
    using System.Text.RegularExpressions;
    using System.Threading.Tasks;
    using UnityEngine;
    using UnityEngine.Networking;
    using Muna;
    using Newtonsoft.Json;
    using Newtonsoft.Json.Converters;
    using NJsonSchema;
    using NJsonSchema.Generation;
    using Internal;
    using static Muna.Beta.OpenAI.SpeechService;
    using BinaryData = Muna.Beta.OpenAI.BinaryData;
    using Status = Internal.VideoKit.Status;

    /// <summary>
    /// Media asset.
    /// </summary>
    public sealed class MediaAsset {

        #region --Enumerations--
        /// <summary>
        /// Media type.
        /// </summary>
        public enum MediaType : int { // CHECK // `VideoKit.h`
            /// <summary>
            /// Unknown or unsupported media type.
            /// </summary>
            [EnumMember(Value = @"unknown")]
            Unknown = 0,
            /// <summary>
            /// Image.
            /// </summary>
            [EnumMember(Value = @"image")]
            Image = 1,
            /// <summary>
            /// Audio.
            /// </summary>
            [EnumMember(Value = @"audio")]
            Audio = 2,
            /// <summary>
            /// Video.
            /// </summary>
            [EnumMember(Value = @"video")]
            Video = 3,
            /// <summary>
            /// Text.
            /// </summary>
            [EnumMember(Value = @"text")]
            Text = 4,
            /// <summary>
            /// Sequence.
            /// </summary>
            [EnumMember(Value = @"sequence")]
            Sequence = 5,
        }

        /// <summary>
        /// Audio narration voice.
        /// </summary>
        [JsonConverter(typeof(StringEnumConverter))]
        public enum NarrationVoice : int {
            /// <summary>
            /// Male 1 narration voice.
            /// </summary>
            [EnumMember(Value = @"kevin")]
            Kevin = 1,
            /// <summary>
            /// Male 2 narration voice.
            /// </summary>
            [EnumMember(Value = @"arjun")]
            Arjun = 2,
            /// <summary>
            /// Male 3 narration voice.
            /// </summary>
            [EnumMember(Value = @"dami")]
            Dami = 3,
            /// <summary>
            /// Male 4 narration voice.
            /// </summary>
            [EnumMember(Value = @"juan")]
            Juan = 4,
            /// <summary>
            /// Female 1 narration voice.
            /// </summary>
            [EnumMember(Value = @"rhea")]
            Rhea = 5,
            /// <summary>
            /// Female 2 narration voice.
            /// </summary>
            [EnumMember(Value = @"aliyah")]
            Aliyah = 6,
            /// <summary>
            /// Female 3 narration voice.
            /// </summary>
            [EnumMember(Value = @"kristen")]
            Kristen = 7,
            /// <summary>
            /// Female 4 narration voice.
            /// </summary>
            [EnumMember(Value = @"salma")]
            Salma = 8,
        }
        #endregion


        #region --Properties--
        /// <summary>
        /// Path to media asset.
        /// This is `null` for sequence assets.
        /// </summary>
        public string? path {
            get {
                var sb = new StringBuilder(2048);
                var status = handle.GetMediaAssetPath(sb, sb.Capacity);
                return status == Status.Ok ? sb.ToString() : null;
            }
        }

        /// <summary>
        /// Asset media type.
        /// </summary>
        public MediaType type => handle.GetMediaAssetMediaType(out var type).Throw() == Status.Ok ? type : default;

        /// <summary>
        /// Image or video width.
        /// </summary>
        public int width => handle.GetMediaAssetWidth(out var width) == Status.Ok ? width : default;

        /// <summary>
        /// Image or video height.
        /// </summary>
        public int height => handle.GetMediaAssetHeight(out var height) == Status.Ok ? height : default;

        /// <summary>
        /// Video frame rate.
        /// </summary>
        public float frameRate => handle.GetMediaAssetFrameRate(out var frameRate) == Status.Ok ? frameRate : default;

        /// <summary>
        /// Audio sample rate.
        /// </summary>
        public int sampleRate => handle.GetMediaAssetSampleRate(out var sampleRate) == Status.Ok ? sampleRate : default;

        /// <summary>
        /// Audio channel count.
        /// </summary>
        public int channelCount => handle.GetMediaAssetChannelCount(out var channelCount) == Status.Ok ? channelCount : default;

        /// <summary>
        /// Video or audio duration in seconds.
        /// </summary>
        public float duration => handle.GetMediaAssetDuration(out var duration) == Status.Ok ? duration : default;

        /// <summary>
        /// Media assets contained within this asset.
        /// This is only populated for `Sequence` assets.
        /// </summary>
        public IReadOnlyList<MediaAsset> assets => new NativeMediaSequence(this);
        #endregion


        #region --Creators--
        /// <summary>
        /// Create a media aseet from a file.
        /// </summary>
        /// <param name="path">Path to media file.</param>
        /// <returns>Media asset.</returns>
        public static Task<MediaAsset> FromFile(string path) {
            var tcs = new TaskCompletionSource<MediaAsset>();
            var handle = GCHandle.Alloc(tcs, GCHandleType.Normal);
            try {
                VideoKit.CreateMediaAsset(path, OnCreateAsset, (IntPtr)handle).Throw();
            } catch (Exception ex) {
                handle.Free();
                tcs.SetException(ex);
            }
            return tcs.Task;
        }

        /// <summary>
        /// Create a media aseet from a texture.
        /// </summary>
        /// <param name="texture">Texture.</param>
        /// <returns>Image asset.</returns>
        public static Task<MediaAsset> FromTexture(Texture2D texture) {
            // Check
            if (texture == null)
                return Task.FromException<MediaAsset>(new ArgumentNullException(nameof(texture)));
            // Check
            if (!texture.isReadable)
                return Task.FromException<MediaAsset>(new ArgumentException(@"Cannot create media asset from texture that is not readable"));
            // Write to file
            var encoded = texture.EncodeToPNG();
            var name = Guid.NewGuid().ToString("N");
            var path = Path.Combine(Application.temporaryCachePath, $"{name}.png");
            File.WriteAllBytes(path, encoded);
            // Create asset
            return FromFile(path);
        }

        /// <summary>
        /// Create a media aseet from an audio clip.    
        /// NOTE: This requires an active VideoKit plan.
        /// </summary>
        /// <param name="clip">Audio clip.</param>
        /// <param name="format">Media format used to encode the audio.</param>
        /// <returns>Audio asset.</returns>
        public static async Task<MediaAsset> FromAudioClip(
            AudioClip clip,
            MediaRecorder.Format format = MediaRecorder.Format.WAV
        ) {
            // Create audio buffer
            var sampleBuffer = new float[clip.samples * clip.channels];
            clip.GetData(sampleBuffer, 0);
            using var audioBuffer = new AudioBuffer(clip.frequency, clip.channels, sampleBuffer);
            // Create asset
            var recorder = await MediaRecorder.Create(
                format,
                sampleRate: audioBuffer.sampleRate,
                channelCount: audioBuffer.channelCount
            );
            recorder.Append(audioBuffer);
            var asset = await recorder.FinishWriting();
            // Return
            return asset;
        }

        /// <summary>
        /// Create a media aseet from plain text.
        /// </summary>
        /// <param name="text">Text.</param>
        /// <returns>Text asset.</returns>
        public static Task<MediaAsset> FromText(string text) {
            // Write to file
            var name = Guid.NewGuid().ToString("N");
            var path = Path.Combine(Application.temporaryCachePath, $"{name}.txt");
            File.WriteAllText(path, text);
            // Create asset
            return FromFile(path);
        }

        /// <summary>
        /// Create a media asset by prompting the user to select an image or video from the camera roll.
        /// NOTE: This requires iOS 14+.
        /// </summary>
        /// <param name="type">Desired asset type.</param>
        /// <returns>Media asset.</returns>
        public static Task<MediaAsset?> FromCameraRoll(MediaType type) {
            var tcs = new TaskCompletionSource<MediaAsset?>();
            var handle = GCHandle.Alloc(tcs, GCHandleType.Normal);
            try {
                VideoKit.CreateMediaAssetFromCameraRoll(type, OnCreateAsset, (IntPtr)handle).Throw();
            } catch (Exception ex) {
                handle.Free();
                tcs.SetException(ex);
            }
            return tcs.Task;
        }

        /// <summary>
        /// Create a media asset from a file in `StreamingAssets`.
        /// </summary>
        /// <param name="path">Relative file path in `StreamingAssets`.</param>
        /// <returns>Media asset.</returns>
        public static async Task<MediaAsset?> FromStreamingAssets(string path) {
            // Get absolute path
            var absolutePath = await StreamingAssetsToAbsolutePath(path);
            if (absolutePath == null)
                throw new InvalidOperationException($"Failed to create media asset because file '{path}' could not be found in `StreamingAssets`");
            // Create asset
            return await FromFile(absolutePath);
        }

        /// <summary>
        /// Create a media asset by concatenating a set of media assets.
        /// </summary>
        /// <param name="assets">Media assets to concatenate.</param>
        /// <returns>Concatenated media asset.</returns>
        public static Task<MediaAsset> FromConcatenatingAssets(params MediaAsset[] assets) => FromConcatenatingAssets(
            assets,
            format: MediaRecorder.Format.MP4
        );

        /// <summary>
        /// Create a media asset by concatenating a set of media assets.
        /// </summary>
        /// <param name="assets">Media assets to concatenate.</param>
        /// <param name="format">Destination format for concatenated media asset.</param>
        /// <param name="prefix">Subdirectory name to save recordings. This will be created if it does not exist.</param>
        /// <returns>Concatenated media asset.</returns>
        public static async Task<MediaAsset> FromConcatenatingAssets(
            MediaAsset[] assets,
            MediaRecorder.Format format,
            string? prefix = null
        ) {
            // Check
            if (assets.Length == 0)
                throw new ArgumentException(@"Concatenate requires at least one media asset");
            // Check all videos
            if (assets.Any(asset => asset.type != MediaType.Video))
                throw new NotImplementedException(@"Concatenate only supports video assets");
            // Check resolution
            var width = assets[0].width;
            var height = assets[0].height;
            if (assets.Any(asset => asset.width != width || asset.height != height))
                throw new ArgumentException(@"Concatenate requires that all videos have the same resolution");
            // Check no audio
            if (assets.Any(asset => asset.sampleRate > 0 && asset.channelCount > 0))
                throw new NotImplementedException(@"Concatenate only supports videos without audio");
            // Create destination recorder
            var frameRate = assets[0].frameRate;
            var recorder = await MediaRecorder.Create(
                format: format,
                width: width,
                height: height,
                frameRate: frameRate,
                sampleRate: 0,
                channelCount: 0,
                prefix: prefix
            );
            // Append frames
            var data = new byte[width * height * 4];
            var handle = GCHandle.Alloc(data, GCHandleType.Pinned);
            var dataPtr = handle.AddrOfPinnedObject();
            var timebase = 0L;
            try {
                foreach (var asset in assets) {
                    var lastTimestamp = 0L;
                    foreach (var srcBuffer in asset.Read<PixelBuffer>()) {
                        using var dstBuffer = Wrap(
                            dataPtr,
                            width,
                            height,
                            timebase + srcBuffer.timestamp
                        );
                        srcBuffer.CopyTo(dstBuffer);
                        recorder.Append(dstBuffer);
                        lastTimestamp = dstBuffer.timestamp;
                    }
                    timebase = lastTimestamp + (long)(1e+9f / frameRate);
                }
            } finally {
                handle.Free();
            }
            // Finish
            return await recorder.FinishWriting();
            // Helper
            static unsafe PixelBuffer Wrap(IntPtr handle, int width, int height, long timestamp) => new(
                width: width,
                height: height,
                format: PixelBuffer.Format.RGBA8888,
                data: (byte*)handle,
                timestamp: timestamp
            );
        }

        /// <summary>
        /// Create a media asset by performing text-to-speech on the provided text prompt.
        /// </summary>
        /// <param name="prompt">Text to synthesize speech from.</param>
        /// <param name="voice">Voice to use for generation. See https://videokit.ai/reference/mediaasset for more information.</param>
        /// <param name="speed">Audio speed of the generated speech.</param>
        /// <param name="acceleration">Prediction acceleration.</param>
        /// <returns>Generated audio asset.</returns>
        internal static async Task<MediaAsset> FromGeneratedSpeech( // INCOMPLETE
            string prompt,
            NarrationVoice voice,
            float speed = 1f,
            string? acceleration = default
        ) {
            var openai = VideoKitClient.Instance!.muna.Beta.OpenAI;
            var tag = SpeechPredictorMap[voice];
            var speech = await openai.Audio.Speech.Create(
                model: tag,
                input: prompt,
                voice: GetEnumValueString(voice)!,
                speed: speed,
                responseFormat: ResponseFormat.PCM,
                acceleration: acceleration
            );
            var clip = ToAudioClip(speech);
            var asset = await FromAudioClip(clip);
            return asset;
        }

        /// <summary>
        /// Create a media asset by transcribing on the provided audio clip.
        /// </summary>
        /// <param name="audio">Audio clip to transcribe.</param>
        /// <returns>Transcribed text asset.</returns>
        public static async Task<MediaAsset> FromGeneratedTranscription(AudioClip audio) {
            var audioAsset = await FromAudioClip(audio, MediaRecorder.Format.WAV);
            var transcriptionAsset = await FromGeneratedTranscription(audioAsset.path);
            return transcriptionAsset;
        }

        /// <summary>
        /// Create a media asset by transcribing on the provided audio clip.
        /// </summary>
        /// <param name="path">Path to audio file.</param>
        /// <param name="acceleration">Prediction acceleration.</param>
        /// <returns>Transcribed text asset.</returns>
        public static async Task<MediaAsset> FromGeneratedTranscription(
            string path,
            string? acceleration = default
        ) {
            var openai = VideoKitClient.Instance!.muna.Beta.OpenAI;
            using var stream = File.OpenRead(path);
            var transcription = await openai.Audio.Transcriptions.Create(
                model: TranscribeTag,
                file: stream,
                acceleration: acceleration
            );
            var asset = await FromText(transcription.Text);
            return asset;
        }

        /// <summary>
        /// Create a media asset by performing text-to-image on the provided text prompt.
        /// </summary>
        /// <param name="prompt">Text prompt to use to generate the image.</param>
        /// <param name="width">Desired image width. NOTE: The generated image is not guaranteed to have this width.</param>
        /// <param name="height">Desired image height. NOTE: The generated image is not guaranteed to have this height.</param>
        /// <returns>Generated image asset.</returns>
        internal static async Task<MediaAsset> FromGeneratedImage( // INCOMPLETE
            string prompt,
            int width = 1024,
            int height = 1024
        ) {
            return default;
        }
        #endregion


        #region --Converters--
        /// <summary>
        /// Read text from the media asset.
        /// This can only be used on text assets.
        /// </summary>
        public string ToText() {
            // Check type
            if (type != MediaType.Text)
                throw new ArgumentException(@"`MediaAsset.ToText` can only be used on text assets");
            // Check path
            if (string.IsNullOrEmpty(path))
                throw new InvalidOperationException("Text asset does not have a valid file path");
            // Read text
            return File.ReadAllText(path);
        }

        /// <summary>
        /// Create a texture from the media asset.
        /// This can only be used on image and video assets.
        /// </summary>
        /// <param name="time">Time to extract the texture from. This is only supported for video assets.</param>
        /// <returns>Texture.</returns>
        public async Task<Texture2D> ToTexture(float time = 0f) {
            // Check video
            if (type == MediaType.Video)
                throw new NotImplementedException(@"`MediaAsset.ToTexture` is not yet supported for video assets");
            // Check type
            if (type != MediaType.Image)
                throw new ArgumentException(@"`MediaAsset.ToTexture` can only be used on image assets");
            // Load data
            var uri = path![0] == '/' ? $"file://{path}" : path;
            using var request = UnityWebRequestTexture.GetTexture(uri);
            request.SendWebRequest();
            while (!request.isDone)
                await Task.Yield();
            // Check
            if (request.result != UnityWebRequest.Result.Success)
                throw new InvalidOperationException($"Image asset could not be loaded with error: {request.error}");
            // Return
            return DownloadHandlerTexture.GetContent(request);
        }

        /// <summary>
        /// Create an audio clip from the media asset.
        /// </summary>
        /// <returns>Audio clip.</returns>
        public async Task<AudioClip> ToAudioClip() { // CHECK // WAV only for now
            // Check type
            if (type != MediaType.Audio)
                throw new ArgumentException($"Cannot create audio clip from asset because asset has invalid type: {type}");
            // Load data
            var uri = path![0] == '/' ? $"file://{path}" : path;
            using var request = UnityWebRequestMultimedia.GetAudioClip(uri, AudioType.WAV);
            request.SendWebRequest();
            while (!request.isDone)
                await Task.Yield();
            // Check
            if (request.result != UnityWebRequest.Result.Success)
                throw new InvalidOperationException($"Audio clip could not be loaded with error: {request.error}");
            // Return
            return DownloadHandlerAudioClip.GetContent(request);
        }
        #endregion


        #region --Reading--
        /// <summary>
        /// Read sample buffers in the media asset.
        /// </summary>
        /// <returns>Sample buffers in the media asset.</returns>
        public IEnumerable<T> Read<T>() where T : struct {
            var type = GetMediaType<T>();
            foreach (var sampleBuffer in Read(type)) {
                if (type == MediaType.Video)
                    yield return (T)(object)new PixelBuffer(sampleBuffer); // sexy code is worth boxing overhead :p
                else if (type == MediaType.Audio)
                    yield return (T)(object)new AudioBuffer(sampleBuffer);
                else
                    break;
            }
        }

        /// <summary>
        /// Parse the text asset into a structure.
        /// </summary>
        /// <typeparam name="T">Structure to parse into.</typeparam>
        /// <returns>Parsed structure.</returns>
        internal async Task<T> Parse<T>() {
            // Check
            if (type != MediaType.Text)
                throw new ArgumentException($"Cannot perform structured parsing on media asset because asset is not a text asset");
            // Generate schema
            var settings = new JsonSchemaGeneratorSettings {
                GenerateAbstractSchemas = false,
                GenerateExamples = false,
                UseXmlDocumentation = false,
                ResolveExternalXmlDocumentation = false,
                FlattenInheritanceHierarchy = false,
            };
            var schema = JsonSchema.FromType<T>(settings);
            // Parse
            
            return default;
        }

        /// <summary>
        /// Take a sub-range of a media asset.
        /// </summary>
        /// <param name="duration">Duration in seconds.</param>
        /// <param name="format">Destination format for result media asset.</param>
        /// <param name="prefix">Subdirectory name to save recordings. This will be created if it does not exist.</param>
        /// <returns>Result media asset.</returns>
        public Task<MediaAsset> Take(
            float duration,
            MediaRecorder.Format format = MediaRecorder.Format.MP4,
            string? prefix = null
        ) => Take(
            duration: TimeSpan.FromSeconds(duration), 
            format: format,
            prefix: prefix
        );

        /// <summary>
        /// Take a sub-range of a media asset.
        /// </summary>
        /// <param name="duration">Duration.</param>
        /// <param name="format">Destination format for result media asset.</param>
        /// <param name="prefix">Subdirectory name to save recordings. This will be created if it does not exist.</param>
        /// <returns>Result media asset.</returns>
        public async Task<MediaAsset> Take(
            TimeSpan duration,
            MediaRecorder.Format format = MediaRecorder.Format.MP4,
            string? prefix = null
        ) {
            // Check video
            if (type != MediaType.Video)
                throw new NotImplementedException(@"Trimming media assets is only supported for videos");
            // Check audio
            if (sampleRate > 0 && channelCount > 0)
                throw new NotImplementedException(@"Trimming videos with audio is not yet supported");
            // Check asset duration
            if (this.duration < duration.TotalSeconds)
                return this;
            // Create recorder
            var recorder = await MediaRecorder.Create(
                format: format,
                width: width,
                height: height,
                frameRate: frameRate,
                sampleRate: 0,
                channelCount: 0,
                prefix: prefix
            );
            // Copy
            var data = new byte[width * height * 4];
            var handle = GCHandle.Alloc(data, GCHandleType.Pinned);
            var dataPtr = handle.AddrOfPinnedObject();
            try {
                foreach (var srcBuffer in Read<PixelBuffer>()) {
                    var timestamp = srcBuffer.timestamp;
                    if (timestamp > duration.TotalMilliseconds * 1e+6f)
                        break;
                    using var dstBuffer = Wrap(
                        dataPtr,
                        width,
                        height,
                        srcBuffer.timestamp
                    );
                    srcBuffer.CopyTo(dstBuffer);
                    recorder.Append(dstBuffer);
                }
            } finally {
                handle.Free();
            }
            // Finish
            return await recorder.FinishWriting();
            // Helper
            static unsafe PixelBuffer Wrap(IntPtr handle, int width, int height, long timestamp) => new(
                width: width,
                height: height,
                format: PixelBuffer.Format.RGBA8888,
                data: (byte*)handle,
                timestamp: timestamp
            );
        }

        /// <summary>
        /// Take a sub-range of a media asset from the end.
        /// </summary>
        /// <param name="duration">Duration in seconds.</param>
        /// <param name="format">Destination format for result media asset.</param>
        /// <param name="prefix">Subdirectory name to save recordings. This will be created if it does not exist.</param>
        /// <returns>Result media asset.</returns>
        public Task<MediaAsset> TakeLast(
            float duration,
            MediaRecorder.Format format = MediaRecorder.Format.MP4,
            string? prefix = null
        ) => TakeLast(
            duration: TimeSpan.FromSeconds(duration),
            format: format,
            prefix: prefix
        );

        /// <summary>
        /// Take a sub-range of a media asset.
        /// </summary>
        /// <param name="duration">Duration in seconds.</param>
        /// <param name="format">Destination format for result media asset.</param>
        /// <param name="prefix">Subdirectory name to save recordings. This will be created if it does not exist.</param>
        /// <returns>Result media asset.</returns>
        public async Task<MediaAsset> TakeLast(
            TimeSpan duration,
            MediaRecorder.Format format = MediaRecorder.Format.MP4,
            string? prefix = null
        ) {
            // Check video
            if (type != MediaType.Video)
                throw new NotImplementedException(@"Trimming media assets is only supported for videos");
            // Check audio
            if (sampleRate > 0 && channelCount > 0)
                throw new NotImplementedException(@"Trimming videos with audio is not yet supported");
            // Check asset duration
            if (this.duration < duration.TotalSeconds)
                return this;
            // Create recorder
            var recorder = await MediaRecorder.Create(
                format: format,
                width: width,
                height: height,
                frameRate: frameRate,
                sampleRate: 0,
                channelCount: 0,
                prefix: prefix
            );
            // Copy
            var data = new byte[width * height * 4];
            var handle = GCHandle.Alloc(data, GCHandleType.Pinned);
            var dataPtr = handle.AddrOfPinnedObject();
            var durationNs = (long)(duration.TotalMilliseconds * 1e+6f);
            var assetDurationNs = (long)(this.duration * 1e+9f);
            var startTimeNs = assetDurationNs - durationNs;
            long? timebaseNs = null;
            try {
                foreach (var srcBuffer in Read<PixelBuffer>()) {
                    var timestamp = srcBuffer.timestamp;
                    if (timestamp < startTimeNs)
                        continue;
                    if (timebaseNs == null)
                        timebaseNs = timestamp;
                    using var dstBuffer = Wrap(
                        dataPtr,
                        width,
                        height,
                        timestamp - timebaseNs.Value
                    );
                    srcBuffer.CopyTo(dstBuffer);
                    recorder.Append(dstBuffer);
                }
            } finally {
                handle.Free();
            }
            // Finish
            return await recorder.FinishWriting();
            // Helper
            static unsafe PixelBuffer Wrap(IntPtr handle, int width, int height, long timestamp) => new(
                width: width,
                height: height,
                format: PixelBuffer.Format.RGBA8888,
                data: (byte*)handle,
                timestamp: timestamp
            );
        }
        #endregion


        #region --Sharing--
        /// <summary>
        /// Share the media asset using the native sharing UI.
        /// </summary>
        /// <param name="message">Optional message to share with the media asset.</param>
        /// <returns>Receiving app bundle ID or `null` if the user did not complete the share action.</returns>
        public Task<string?> Share(string? message = null) {
            // Check
            if (type == MediaType.Sequence)
                throw new InvalidOperationException(@"Sequence assets cannot be shared");
            // Share
            var tcs = new TaskCompletionSource<string?>();
            var handle = GCHandle.Alloc(tcs, GCHandleType.Normal);
            try {
                this.handle.ShareMediaAsset(
                    message,
                    OnShare,
                    (IntPtr)handle
                ).Throw();
            } catch (NotImplementedException) {
                tcs.SetResult(null);
                handle.Free();
            } catch (Exception ex) {
                tcs.SetException(ex);
                handle.Free();
            }
            // Return
            return tcs.Task;
        }

        /// <summary>
        /// Save the media asset to the camera roll.
        /// </summary>
        /// <param name="album">Optional album to save media asset to.</param>
        /// <returns>Whether the asset was successfully saved to the camera roll.</returns>
        public Task<bool> SaveToCameraRoll(string? album = null) {
            // Check
            if (type == MediaType.Sequence)
                throw new InvalidOperationException(@"Sequence assets cannot be saved to the camera roll");
            // Save
            var tcs = new TaskCompletionSource<bool>();
            var handle = GCHandle.Alloc(tcs, GCHandleType.Normal);
            try {
                this.handle.SaveMediaAssetToCameraRoll(
                    album,
                    OnSaveToCameraRoll,
                    (IntPtr)handle
                ).Throw();
            } catch (NotImplementedException) {
                tcs.SetResult(false);
                handle.Free();
            } catch (Exception ex) {
                tcs.SetException(ex);
                handle.Free();
            }
            // Return
            return tcs.Task;
        }
        #endregion


        #region --Operations--
        private readonly IntPtr handle;
        private readonly MediaAsset? parent;
        private static readonly Dictionary<NarrationVoice, string> SpeechPredictorMap = new() { // INCOMPLETE
            
        };
        internal const string TranscribeTag = @"@videokit/transcribe-v1";

        internal MediaAsset(IntPtr handle, MediaAsset? parent = null) {
            this.handle = handle;
            this.parent = parent;
        }

        ~MediaAsset() {
            if (parent == null)
                handle.ReleaseMediaAsset();
        }

        private IEnumerable<IntPtr> Read(MediaType type) {
            handle.CreateMediaReader(type, out var reader).Throw();
            try {
                for (;;) {
                    var status = reader.ReadNextSampleBuffer(out var sampleBuffer);
                    if (status == Status.InvalidOperation)
                        break;
                    if (sampleBuffer == default)
                        continue;
                    yield return sampleBuffer;
                    sampleBuffer.ReleaseSampleBuffer();
                }
            } finally {
                reader.ReleaseMediaReader();
            }
        }

        public static implicit operator IntPtr(MediaAsset asset) => asset.handle;
        #endregion


        #region --Callbacks--

        [MonoPInvokeCallback(typeof(VideoKit.MediaAssetHandler))]
        private static void OnCreateAsset(IntPtr context, IntPtr asset) {
            try {
                if (!VideoKit.IsAppDomainLoaded)
                    return;
                var handle = (GCHandle)context;
                var tcs = handle.Target as TaskCompletionSource<MediaAsset?>;
                handle.Free();
                tcs?.SetResult(asset != IntPtr.Zero ? new MediaAsset(asset) : null);
            } catch (Exception ex) {
                Debug.LogException(ex);
            }
        }

        [MonoPInvokeCallback(typeof(VideoKit.MediaAssetShareHandler))]
        private static void OnShare(IntPtr context, IntPtr receiver) {
            try {
                // Check
                if (!VideoKit.IsAppDomainLoaded)
                    return;
                // Get tcs
                var handle = (GCHandle)context;
                var tcs = handle.Target as TaskCompletionSource<string>;
                handle.Free();
                // Complete task
                var result = Marshal.PtrToStringUTF8(receiver);
                tcs?.SetResult(result);
            } catch (Exception ex) {
                Debug.LogException(ex);
            }
        }

        [MonoPInvokeCallback(typeof(VideoKit.MediaAssetShareHandler))]
        private static void OnSaveToCameraRoll(IntPtr context, IntPtr receiver) {
            try {
                // Check
                if (!VideoKit.IsAppDomainLoaded)
                    return;
                // Get tcs
                var handle = (GCHandle)context;
                var tcs = handle.Target as TaskCompletionSource<bool>;
                handle.Free();
                // Complete task
                var result = receiver != IntPtr.Zero;
                tcs?.SetResult(result);
            } catch (Exception ex) {
                Debug.LogException(ex);
            }
        }
        #endregion


        #region --Utilities--

        private static async Task<string?> StreamingAssetsToAbsolutePath(string relativePath) {
            var fullPath = Path.Combine(Application.streamingAssetsPath, relativePath);
            if (Application.platform != RuntimePlatform.Android)
                return File.Exists(fullPath) ? fullPath : null;
            var persistentPath = Path.Combine(Application.persistentDataPath, relativePath);
            if (File.Exists(persistentPath))
                return persistentPath;
            var directory = Path.GetDirectoryName(persistentPath);
            Directory.CreateDirectory(directory);
            using var request = UnityWebRequest.Get(fullPath);
            request.SendWebRequest();
            while (!request.isDone)
                await Task.Yield();
            if (request.result != UnityWebRequest.Result.Success)
                return null;
            File.WriteAllBytes(persistentPath, request.downloadHandler.data);
            return persistentPath;
        }

        private static MediaType GetMediaType<T>() => typeof(T) switch {
            var x when x == typeof(AudioBuffer) => MediaType.Audio,
            var x when x == typeof(PixelBuffer) => MediaType.Video,
            _ => MediaType.Unknown,
        };

        private static string? GetEnumValueString(Enum value) {
            var fieldInfo = value.GetType().GetField(value.ToString());
            var attribute = fieldInfo?
                .GetCustomAttributes(typeof(EnumMemberAttribute), false)?
                .FirstOrDefault() as EnumMemberAttribute;
            return (attribute?.IsValueSetExplicitly ?? false) ? attribute.Value : null;
        }
        
        private static unsafe AudioClip ToAudioClip(BinaryData data) {
            // Match sample rate and channel count
            var rateMatch = Regex.Match(data.MediaType, @"rate=(\d+)");
            var channelsMatch = Regex.Match(data.MediaType, @"channels=(\d+)");
            if (!rateMatch.Success || !channelsMatch.Success)
                throw new ArgumentException($"Failed to extract audio format from speech binary data because media type is invalid: '{data.MediaType}'");
            // Parse
            if (!int.TryParse(rateMatch.Groups[1].Value, out var sampleRate))
                throw new ArgumentException($"Failed to parse sample rate from speech binary data because it is invalid: '{rateMatch.Value}'");
            if (!int.TryParse(channelsMatch.Groups[1].Value, out var channelCount))
                throw new ArgumentException($"Failed to parse channel count from speech binary data because it is invalid: '{channelsMatch.Value}'");
            // Create clip
            var sampleCount = data.Length / sizeof(float);
            var frameCount = sampleCount / channelCount;
            var clip = AudioClip.Create(
                "audio",
                lengthSamples: frameCount,
                channels: channelCount,
                frequency: sampleRate,
                stream: false
            );
            // Copy data
            var samples = new float[sampleCount];
            Buffer.BlockCopy(data.ToArray(), 0, samples, 0, data.Length);
            clip.SetData(samples, 0);
            // Return
            return clip;
        }

        private readonly struct NativeMediaSequence : IReadOnlyList<MediaAsset?> {

            private readonly MediaAsset asset;

            public NativeMediaSequence(MediaAsset asset) => this.asset = asset;

            public int Count {
                get {
                    if (asset.handle.GetMediaAssetSubAssetCount(out var count) == Status.Ok)
                        return count;
                    return default;
                }
            }

            public MediaAsset? this[int index] {
                get {
                    asset.handle.GetMediaAssetSubAsset(index, out var subAsset).Throw();
                    return new MediaAsset(subAsset, parent: asset);
                }
            }
    
            IEnumerator<MediaAsset?> IEnumerable<MediaAsset?>.GetEnumerator() {
                for (var idx = 0; idx < Count; ++idx)
                    yield return this[idx];
            }

            IEnumerator IEnumerable.GetEnumerator() => (this as IEnumerable<MediaAsset>).GetEnumerator();
        }
        #endregion


        #region --Deprecated--
        [Obsolete(@"Deprecated in VideoKit 1.0.11. Use `MediaAsset.FromConcatenatingAssets` static method instead.")]
        public static Task<MediaAsset> Concatenate(params MediaAsset[] assets) => FromConcatenatingAssets(
            assets,
            format: MediaRecorder.Format.MP4
        );
        
        [Obsolete(@"Deprecated in VideoKit 1.0.11. Use `MediaAsset.FromConcatenatingAssets` static method instead.")]
        public static Task<MediaAsset> Concatenate(
            MediaAsset[] assets,
            MediaRecorder.Format format,
            string? prefix = null
        ) => FromConcatenatingAssets(assets, format: format, prefix: prefix);

        [Obsolete(@"Deprecated in VideoKit 1.0.11. Use `MediaAsset.Take` instance method instead.")]
        public static Task<MediaAsset> Take(
            MediaAsset asset,
            float duration,
            MediaRecorder.Format format = MediaRecorder.Format.MP4,
            string? prefix = null
        ) => asset.Take(duration, format: format, prefix: prefix);

        [Obsolete(@"Deprecated in VideoKit 1.0.11. Use `MediaAsset.Take` instance method instead.")]
        public static Task<MediaAsset> Take(
            MediaAsset asset,
            TimeSpan duration,
            MediaRecorder.Format format = MediaRecorder.Format.MP4,
            string? prefix = null
        ) => asset.Take(duration, format: format, prefix: prefix);

        [Obsolete(@"Deprecated in VideoKit 1.0.11. Use `MediaAsset.TakeLast` instance method instead.")]
        public static Task<MediaAsset> TakeLast(
            MediaAsset asset,
            float duration,
            MediaRecorder.Format format = MediaRecorder.Format.MP4,
            string? prefix = null
        ) => asset.TakeLast(duration, format: format, prefix: prefix);
        #endregion
    }
}