using BITKit.IO;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WebDav;

namespace BITKit.Web
{
    public class WebFileProvider : IStorageFile
    {
        public WebFileProvider(IWebDavClient client,string requestUrl)
        {
            this.client = client;
            this.requestUrl = requestUrl;
        }
        readonly string requestUrl;
        IWebDavClient client { get; set; }
        public Stream CreateFile()
        {
            throw new NotImplementedException();
        }

        public string GetFileType()
        {
            throw new NotImplementedException();
        }

        public DateTime GetLastUpdated()
        {
            throw new NotImplementedException();
        }

        public string GetName()
        {
            return requestUrl;
        }

        public string GetPath()
        {
            return requestUrl;
        }

        public long GetSize()
        {
            throw new NotImplementedException();
        }

        public string GetText()
        {
            MemoryStream memory = new MemoryStream();
            var task = client.GetRawFile(requestUrl);
            task.Wait();
            task.Result.Stream.CopyTo(memory);
            var value =StringHelper.GetString(memory.GetBuffer());
            memory.Dispose();
            task.Result.Stream.Dispose();
            return value;
        }

        public Stream OpenRead()
        {
            throw new NotImplementedException();
        }

        public Stream OpenWrite()
        {
            throw new NotImplementedException();
        }

        public async Task<Stream> OpenReadAsync()
        {
            var file = await client.GetRawFile(requestUrl);
            if(file.IsSuccessful)
            {
                var tempPath = PathHelper.GetTempFilePath(requestUrl);
                using (var fs = File.Create(tempPath))
                {
                    await file.Stream.CopyToAsync(fs, BITApp.CancellationTokenSource.Token);
                    fs.Close();
                }
                {
                    var fs = File.OpenRead(tempPath);
                    return fs;
                }
            }
            else
            {
                throw new Exception($"Get WebDav file [{requestUrl}] error:{file.StatusCode}");
            }
        }
        public async Task<Stream> OpenWriteAsync()
        {
            var file = await client.GetRawFile(requestUrl);
            return file.Stream;
        }

        public Task<Stream> CreateFileAsync()
        {
            throw new NotImplementedException();
        }

        public async Task<string> GetTextAsync()
        {
            var file = await client.GetRawFile(requestUrl);
            if(file.IsSuccessful)
            {
                using (StreamReader reader = new(file.Stream))
                {
                    return reader.ReadToEnd();
                }
            }
            else
            {
               throw new Exception($"WebDavError:{file.StatusCode}");
            }
        }
            
    }
}