/*
 *                     GNU AFFERO GENERAL PUBLIC LICENSE
 *                       Version 3, 19 November 2007
 *  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
 *  Everyone is permitted to copy and distribute verbatim copies
 *  of this license document, but changing it is not allowed.
 */

using System;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using UVtools.Core.Extensions;
using UVtools.Core.Objects;
using UVtools.Core.Operations;

namespace UVtools.Core.Network
{
    public class RemotePrinterRequest : BindableBase
    {
        #region Enums

        public enum RequestMethod : byte
        {
            [Description("GET")]
            GET,

            [Description("POST")]
            POST,

            [Description("PUT")]
            PUT
        }

        public enum RequestType : byte
        {
            UploadFile,
            PrintFile,
            DeleteFile,
            PausePrint,
            ResumePrint,
            StopPrint,
            GetFiles,
            PrintStatus,
            PrinterInfo,
        }

        #endregion

        #region Members
        private RequestType _type;
        private RequestMethod _method;
        private string _path = "";
        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets this request type
        /// </summary>
        public RequestType Type
        {
            get => _type;
            set => RaiseAndSetIfChanged(ref _type, value);
        }


        /// <summary>
        /// Gets or sets this request method
        /// </summary>
        public RequestMethod Method
        {
            get => _method;
            set => RaiseAndSetIfChanged(ref _method, value);
        }

        /// <summary>
        /// Gets or sets the request path, eg: print/file/{0}
        /// </summary>
        public string Path
        {
            get => _path;
            set
            {
                if (!string.IsNullOrWhiteSpace(value))
                {
                    value = value.Trim();
                    if (value[0] == '/') value = value.Remove(0, 1);
                    if(value[^1] == '/') value = value.Remove(value.Length-1, 1);
                }
                if(!RaiseAndSetIfChanged(ref _path, value)) return;
                RaisePropertyChanged(nameof(IsValid));
            }
        }

        public bool IsValid => !string.IsNullOrWhiteSpace(_path);

        #endregion

        #region Contructors

        public RemotePrinterRequest() { }

        public RemotePrinterRequest(RequestType type, RequestMethod method, string path = "")
        {
            _type = type;
            _method = method;
            Path = path;
        }

        #endregion


        #region Methods

        /// <summary>
        /// Gets the path with formatted arguments
        /// </summary>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public string GetFormattedPath(params object[] parameters) => _path is null ? null : string.Format(_path, parameters);

        public async Task<HttpResponseMessage> SendRequest(string host, ushort port = 0, OperationProgress progress = null, string param1 = null, HttpContent content = null)
        {
            string url = $"http://{host}";
            if (port > 0) url += $":{port}";

            progress ??= new();
            progress.Title = $"Sending {_method} request to: {url}";
            progress.ItemName = "Megabyte(s)";
            progress.CanCancel = true;

            
            if (!string.IsNullOrWhiteSpace(_path)) url += $"/{GetFormattedPath(param1)}";

            
            if (_method == RequestMethod.GET)
            {
                using var response = await NetworkExtensions.HttpClient.GetAsync(url, progress.Token);
                return response;
            }

            if (_method == RequestMethod.POST)
            {
                using var response = await NetworkExtensions.HttpClient.PostAsync(url, content, progress.Token);
                return response;
            }

            if (_method == RequestMethod.PUT)
            {
                using var response = await NetworkExtensions.HttpClient.PutAsync(url, content, progress.Token);
                return response;
            }

            return null;
        }

        public async Task<HttpResponseMessage> SendRequest(RemotePrinter remotePrinter,
            OperationProgress progress = null, string param1 = null, HttpContent content = null)
            => await SendRequest(remotePrinter.Host, remotePrinter.Port, progress, param1, content);

        public RemotePrinterRequest Clone()
        {
            return MemberwiseClone() as RemotePrinterRequest;
        }

        public override string ToString()
        {
            return _path;
        }

        protected bool Equals(RemotePrinterRequest other)
        {
            return _path == other._path;
        }

        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj)) return false;
            if (ReferenceEquals(this, obj)) return true;
            if (obj.GetType() != this.GetType()) return false;
            return Equals((RemotePrinterRequest)obj);
        }

        public override int GetHashCode()
        {
            return (_path != null ? _path.GetHashCode() : 0);
        }

        #endregion
    }
}