using Avalar.Models.Interfaces;
using Avalar.Utils;
using Avalar.Services.Interfaces;
using Avalonia.Media.Imaging;
using ReactiveUI;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Avalar.Models
{
    public class ImageModel : ReactiveObject, IImageModel, ISettingsModel, IDisposable
    {
        private readonly IResizer m_Resizer;
        private readonly IBrightness m_Brightness;
        private CancellationTokenSource m_CancellationTokenSource;
        private AvalarPipeline m_pipeline;
        private IBitmap m_OriginalBitmap;

        public ImageModel(IServiceProvider serviceProvider)
        {
            m_Resizer = serviceProvider.GetService<IResizer>();
            m_Brightness = serviceProvider.GetService<IBrightness>();

            m_pipeline = new AvalarPipeline(new List<IPipelineStep>
            {
                m_Resizer.AsPipelineStep(),
                m_Brightness.AsPipelineStep()
            });

            m_pipeline.PipelineChanged += OnPipelineChanged;
        }

        public async Task RunPipeline()
        {
            try
            {
                LatestResult = await m_pipeline.Run(m_OriginalBitmap, m_CancellationTokenSource.Token).ConfigureAwait(false);
            } catch (OperationCanceledException)
            {
                
            }
        }

        private async void OnPipelineChanged(object sender, EventArgs e)
        {
            m_CancellationTokenSource?.Cancel();
            m_CancellationTokenSource = new CancellationTokenSource();

            await RunPipeline().ConfigureAwait(false);
        }

        private IBitmap m_LatestResult;
        public IBitmap LatestResult
        {
            get => m_LatestResult;
            set => this.RaiseAndSetIfChanged(ref m_LatestResult, value);
        }

        public IBitmap LoadImage(string imagePath)
        {
            m_OriginalBitmap = new Bitmap(imagePath);
            m_LatestResult = m_OriginalBitmap;
            return m_LatestResult;
        }

        private bool disposed = false;

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposed) return;

            if (disposing)
            {
                m_OriginalBitmap.Dispose();
                m_LatestResult.Dispose();
                m_CancellationTokenSource.Dispose();
            }

            disposed = true;
        }

        public void SetWidth(uint width)
        {
            m_Resizer.Width = width;
        }

        public void SetHeight(uint height)
        {
            m_Resizer.Height = height;
        }

        public void SetBrightnessDelta(int brightnessDelta)
        {
            m_Brightness.Brightness = brightnessDelta;
        }
    }
}