using cwebplusApp.Shared.Models;
using Microsoft.JSInterop;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using TG.Blazor.IndexedDB;

namespace cwebplusApp.Shared.Services {
    public sealed class ReportRepositoryService {

        private const string FoundReportRepository_Store_Name = "FoundReportRepositoryItems";
        private const string MissingReportRepository_Store_Name = "MissingReportRepositoryItems";
        private readonly IJSRuntime jsRuntime;
        private bool initialized;

        private readonly IndexedDBManager dbManager;

        public ReportRepositoryService(IJSRuntime jsRuntime, IndexedDBManager _dbManager) {
            this.jsRuntime = jsRuntime;
            this.dbManager = _dbManager;
        }

        public async Task SaveReport(ReportRepositoryItem reportRepositoryItem) {
            if (reportRepositoryItem is FoundReportRepositoryItem fItem) {
                await SaveFoundReport(fItem);
            } else if (reportRepositoryItem is MissingReportRepositoryItem mItem) {
                await SaveMissingReport(mItem);
            }
        }

        public async ValueTask<List<FoundReportRepositoryItem>> GetFoundReports() {
            return await this.dbManager.GetRecords<FoundReportRepositoryItem>(FoundReportRepository_Store_Name);
        }

        public async ValueTask<List<FoundReportRepositoryItem>> GetPendingFoundReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = FoundReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.PENDING
            };
            return new List<FoundReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, FoundReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<List<FoundReportRepositoryItem>> GetTransmittedFoundReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = FoundReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.TRANSMITTED
            };
            return new List<FoundReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, FoundReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<List<MissingReportRepositoryItem>> GetMissingReports() {
            return await this.dbManager.GetRecords<MissingReportRepositoryItem>(MissingReportRepository_Store_Name);
        }

        public async ValueTask<List<MissingReportRepositoryItem>> GetPendingMissingReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = MissingReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.PENDING
            };
            return new List<MissingReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, MissingReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<List<MissingReportRepositoryItem>> GetTransmittedMissingReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = MissingReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.TRANSMITTED
            };
            return new List<MissingReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, MissingReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<int> GetNbrOfPendingReports() {
            IList<FoundReportRepositoryItem> foundReportRepositoryItems = await GetPendingFoundReports();
            List<MissingReportRepositoryItem> missingReportRepositoryItems = await GetPendingMissingReports();
            return foundReportRepositoryItems.Count + missingReportRepositoryItems.Count;
        }

        public async Task SaveFoundReport(FoundReportRepositoryItem foundReportRepositoryItem) {
            var newRecord = new StoreRecord<FoundReportRepositoryItem> {
                Storename = FoundReportRepository_Store_Name,
                Data = foundReportRepositoryItem
            };
            if (foundReportRepositoryItem.ID == 0) {
                foundReportRepositoryItem.ID = GetCurrentTimeInMillis();
                await this.dbManager.AddRecord(newRecord);
            } else {
                await this.dbManager.UpdateRecord(newRecord);
            }
        }

        public async Task SaveMissingReport(MissingReportRepositoryItem missingReportRepositoryItem) {
            var newRecord = new StoreRecord<MissingReportRepositoryItem> {
                Storename = MissingReportRepository_Store_Name,
                Data = missingReportRepositoryItem
            };
            if (missingReportRepositoryItem.ID == 0) {
                missingReportRepositoryItem.ID = GetCurrentTimeInMillis();
                await this.dbManager.AddRecord(newRecord);
            } else {
                await this.dbManager.UpdateRecord(newRecord);
            }
        }

        public async Task DeleteReport(ReportRepositoryItem reportRepositoryItem) {
            if (reportRepositoryItem is FoundReportRepositoryItem) {
                await this.dbManager.DeleteRecord(FoundReportRepository_Store_Name, reportRepositoryItem.ID);
            } else {
                await this.dbManager.DeleteRecord(MissingReportRepository_Store_Name, reportRepositoryItem.ID);
            }
        }

        public static long GetCurrentTimeInMillis() {
            return DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
        }

        public static string GetCurrentDateTimeFromMillis(long millis) {
            TimeSpan time = TimeSpan.FromMilliseconds(millis);
            DateTime date = new DateTime() + time;
            return date.ToString("dd.MM.yyyy HH:mm:ss");
        }
    }
}