using Moq;
using NUnit.Framework;
using System.Linq;
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using LCU.Api.Internal.DataCleanUp.Configuration;
using LCU.Api.Internal.DataCleanUp.DataAccess;
using LCU.Library.Internal.LcuHttpClient.HttpRequest;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.FileOperationsModels.Models.NameSettings;
namespace LCU.Api.Internal.DataCleanUpTest.DataAccess;

public class FileOperationsDaoTest
{
    private Mock<IGetRequest> _mockgetRequest;
    private Mock<IPostRequest> _mockpostRequest;
    private FileOperationsDao _fileOperationsDao;

    private readonly FileOperationsConfiguration _fileOperationsConfiguration = new FileOperationsConfiguration()
    {
        FileOperationsUrl = "https://localhost:44555",
        GetFile = "/api/FileOperations/",
        WriteFile = "/api/FileOperations/WriteFileData",
        BuildDynamicFileList = "/DynamicFile/BuildDynamicFileList"
    };

    [SetUp]
    public void Setup()
    {
        _mockpostRequest = new Mock<IPostRequest>();
        _mockgetRequest = new Mock<IGetRequest>();
        _fileOperationsDao = new FileOperationsDao(_fileOperationsConfiguration, _mockpostRequest.Object, _mockgetRequest.Object);
    }

    [Test]
    public async Task GetFileContentTest_Success()
    {
        var filename = "testfile.txt";
        var finalFilePath = new string($"{_fileOperationsConfiguration.GetFile}{filename}");
        var testContents = "This is my file content.";

        _mockgetRequest.Setup(x => x.StringResponseAsync(It.IsAny<Uri>(), It.IsAny<int>(), It.IsAny<int>())).ReturnsAsync(testContents).Verifiable();

        var response = await _fileOperationsDao.GetFileContent(finalFilePath);

        Assert.IsNotNull(response);
        Assert.AreEqual("This is my file content.", response);
    }

    [Test]
    public async Task WriteFileTest_Success()
    {
        var writeFileRequest = new WriteFileRequest()
        {
            DestinationPath = "/testDestination",
            FileName = "mytestfile.txt"
        };

        var path = $"{_fileOperationsConfiguration.FileOperationsUrl}{_fileOperationsConfiguration.WriteFile}";
        var uri = new Uri(path);

        var listStringFiles = new List<string>()
        {
            "Testcleanupfile.csv",
            "Testcleanupfile.pdf"
        };

        _mockpostRequest.Setup(x => x.AsyncWithNewton<WriteFileRequest, List<string>>(It.IsAny<Uri>(), It.IsAny<WriteFileRequest>(), It.IsAny<int>(), It.IsAny<int>())).ReturnsAsync(listStringFiles).Verifiable();

        var response = await _fileOperationsDao.WriteFile(writeFileRequest);
        Assert.IsNotNull(response);
        _mockpostRequest.Verify();

    }

    [Test]
    public async Task BuildDynamicFileList_Success()
    {
        var dynamicFileListRequest = new DynamicFileListRequest()
        {
            DynamicFileSettings = new DynamicNameSetting
			{
                DateFormatSettings = null,
                DaysFromToday = 0,
                RegexSettings = null,
            },
             Filename = "mytestfile.txt",
             Path = "//network/Test/"
        };

        var listStringFiles = new List<string>()
        {
            "Testfile.csv",
            "Testfile.pdf"
        };

        var path = $"{_fileOperationsConfiguration.FileOperationsUrl}{_fileOperationsConfiguration.BuildDynamicFileList}";
        var uri = new Uri(path);

        _mockpostRequest.Setup(x => x.Async<DynamicFileListRequest,List<string>>(It.IsAny<Uri>(), It.IsAny<DynamicFileListRequest>(), It.IsAny<int>(), It.IsAny<int>())).ReturnsAsync(listStringFiles).Verifiable();

        var response = await _fileOperationsDao.BuildDynamicFileList(dynamicFileListRequest);

        Assert.IsNotNull(response);
        Assert.AreEqual(2, response.Count());
        Assert.AreEqual("Testfile.pdf", response.Last());
    }
}