using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Dapper;
using Microsoft.Data.Sqlite;
using Serilog;
using SharpRss.Models;

namespace SharpRss.Services
{
    internal class DatabaseService : IDisposable
    {
        internal DatabaseService()
        {
            InitializeDb();
        }
        private readonly string _connectionString = $"Data Source={Path.Combine(Environment.CurrentDirectory, "sharp_rss.sqlite")};";
        private readonly string _groupTable = "group_data";
        private readonly string _feedTable = "feed_data";
        private readonly string _feedItemTable = "feed_item_data";

        // Groups
        public async Task<HashSet<GroupModel>> GetGroupsAsync(string? groupId = null)
        {
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand(groupId != null ? $"SELECT * FROM {_groupTable} WHERE id=@gId;" : $"SELECT * FROM {_groupTable}", dbc)
            {
                Parameters =
                {
                    new SqliteParameter("gId", groupId)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            HashSet<GroupModel> groups = new HashSet<GroupModel>();
            await using SqliteCommand cmdFeedCount = new SqliteCommand($"SELECT COUNT(*) FROM {_feedTable} WHERE group_id=@groupId", dbc);
            while (reader.Read())
            {
                cmdFeedCount.Parameters.Clear();
                cmdFeedCount.Parameters.Add(new SqliteParameter("groupId", reader["id"].ToString()));
                using SqliteDataReader countReader = await cmdFeedCount.ExecuteReaderAsync();
                int count = countReader.Read() ? countReader.GetInt32(0) : 0;

				groups.Add(new GroupModel()
                {
                    Name = reader["name"].ToString(),
                    FeedCount = count,
                    HexColor = reader["hex_color"].ToString(),
                    Icon = reader["icon"].ToString(),
                    Id = reader["id"].ToString()
                });
            }
            return groups;
        }
        public async Task<bool> SetGroupAsync(GroupModel groupModel)
        {
            bool result = false;
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand($"INSERT OR REPLACE INTO {_groupTable} (id, hex_color, icon, name) VALUES (IFNULL((SELECT id FROM {_groupTable} WHERE name=@name), @id), @hexColor, @icon, @name)", dbc)
            {
                Parameters =
                {
                    new SqliteParameter("id", groupModel.Id),
                    new SqliteParameter("hexColor", groupModel.HexColor),
                    new SqliteParameter("icon", groupModel.Icon),
                    new SqliteParameter("name", groupModel.Name)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            return result;
        }
        public async Task<bool> RemoveGroupAsync(GroupModel groupModel)
        {
            bool result = false;
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
			// Remove the group and remove the feeds that were part of the group.
            await using SqliteCommand cmd = new SqliteCommand($"DELETE FROM {_groupTable} WHERE id=@id; UPDATE {_feedTable} SET group_id=NULL WHERE group_id=@id", dbc)
            {
                Parameters =
                {
                    new SqliteParameter("id", groupModel.Id)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            return result;
        }
        // Feeds
        /// <summary>
        /// 
        /// </summary>
        /// <param name="groupId">Empty = ungrouped feeds | null = all feeds | id = grouped feeds</param>
        /// <returns></returns>
        public async Task<HashSet<FeedModel>> GetFeedsAsync(string? groupId = null)
        {
            HashSet<FeedModel> feeds = new HashSet<FeedModel>();
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand(groupId != null ? $"SELECT * FROM {_feedTable} WHERE group_id=@groupId" : $"SELECT * FROM {_feedTable}", dbc)
            {
                Parameters =
                {
                    new SqliteParameter("groupId", groupId ?? string.Empty)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            while (!reader.IsClosed && reader.Read())
                feeds.Add(await ReaderToFeedModel(reader));
            return feeds;
        }
        public async Task<FeedModel?> GetFeedAsync(string feedId)
        {
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            FeedModel? feed = null;
            await using SqliteCommand cmd = new SqliteCommand($"SELECT * FROM {_feedTable} WHERE id=@id", dbc)
            {
                Parameters = { new SqliteParameter("id", feedId) }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            if (reader.Read())
                feed = await ReaderToFeedModel(reader);
            return feed;
        }
        public async Task<FeedModel?> SetFeedAsync(FeedModel feedModel)
        {
            FeedModel? resultModel = null;
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand($"INSERT OR REPLACE INTO {_feedTable} (id, url, title, group_id, feed_type, description, language, copyright, date_added, last_updated, image_url, original_document) VALUES (IFNULL((SELECT id FROM {_feedTable} WHERE url=@url), @id), @url, @title, @groupId, @feedType, @description, @language, @copyright, IFNULL((SELECT date_added FROM {_feedTable} WHERE id=@id), @dateAdded), @lastUpdated, @imageUrl, @originalDoc); SELECT * FROM {_feedTable} WHERE url=@url", dbc)
            {
                Parameters =
                {
                    new SqliteParameter("id", feedModel.Id ?? string.Empty),
                    new SqliteParameter("url", feedModel.Url ?? string.Empty),
                    new SqliteParameter("title", feedModel.Title ?? string.Empty),
                    new SqliteParameter("groupId", feedModel.GroupId ?? string.Empty),
                    new SqliteParameter("feedType", feedModel.FeedType ?? string.Empty),
                    new SqliteParameter("description", feedModel.Description ?? string.Empty),
                    new SqliteParameter("language", feedModel.Language ?? string.Empty),
                    new SqliteParameter("copyright", feedModel.Copyright ?? string.Empty),
                    new SqliteParameter("dateAdded", feedModel.DateAdded?.ToUnixTimeMilliseconds()),
                    new SqliteParameter("lastUpdated", feedModel.LastUpdated?.ToUnixTimeMilliseconds()),
                    new SqliteParameter("imageUrl", feedModel.ImageUrl ?? string.Empty),
                    new SqliteParameter("originalDoc", feedModel.OriginalDocument ?? string.Empty)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            if (reader.Read())
                resultModel = await ReaderToFeedModel(reader);
            return resultModel;
        }
        public async Task<bool> RemoveFeedAsync(FeedModel feedModel)
        {
            bool result = false;
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand($"DELETE FROM {_feedTable} WHERE id=@id; UPDATE {_feedItemTable} SET feed_id=NULL WHERE feed_id=@id", dbc)
            {
                Parameters =
                {
                    new SqliteParameter("id", feedModel.Id)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            return result;
        }
        // Feed items
        public async Task<HashSet<FeedItemModel>> GetFeedItemsAsync(string[]? feedIds = null)
        {
            List<string>? formattedIds = feedIds?.Select(s => $"'{s}'").ToList();
            HashSet<FeedItemModel> feedItems = new HashSet<FeedItemModel>();
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand(
                formattedIds != null
                    ? $"SELECT * FROM {_feedItemTable} WHERE feed_id IN ({string.Join(", ", formattedIds)})"
                    : $"SELECT * FROM {_feedItemTable}", dbc);

            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            while (reader.Read())
            {
                FeedItemModel feedItemModel = new FeedItemModel()
                {
                    Id = reader["id"].ToString(),
                    FeedId = reader["feed_id"].ToString(),
                    Read = int.TryParse(reader["read"].ToString(), out int parsedValue) && parsedValue != 0,
                    Title = reader["title"].ToString(),
                    Description = reader["description"].ToString(),
                    Link = reader["link"].ToString(),
                    LastUpdated =
                        DateTimeOffset.FromUnixTimeMilliseconds(long.Parse(reader["last_updated"].ToString())),
                    PublishingDate =
                        DateTimeOffset.FromUnixTimeMilliseconds(long.Parse(reader["publishing_date"].ToString())),
                    Author = reader["author"].ToString(),
                    Categories = reader["categories"].ToString().Split(','),
                    Content = reader["content"].ToString()
                };
                if (feedItemModel is { FeedId: { } })
                {
                    FeedModel? feedModel = await GetFeedAsync(feedItemModel.FeedId);
                    feedItemModel.Feed = feedModel;
                }
                feedItems.Add(feedItemModel);
            }
            return feedItems;
        }
        public async Task<int> SetFeedItemsAsync(HashSet<FeedItemModel> items)
        {
            int result = 0;
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteTransaction transaction = dbc.BeginTransaction();
            await using SqliteCommand cmd = new SqliteCommand($"INSERT OR REPLACE INTO {_feedItemTable} (id, feed_id, read, title, description, link, last_updated, publishing_date, author, categories, content)" +
                                                              $"VALUES (IFNULL((SELECT id FROM {_feedItemTable} WHERE link=@link), @id), @feedId, @read, @title, @description, @link, @lastUpdated, @publishingDate, @author, @categories, @content)", dbc);
            foreach (FeedItemModel item in items)
            {
                cmd.Parameters.Clear();
                cmd.Parameters.Add(new SqliteParameter("id", item.Id ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("feedId", item.FeedId ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("read", item.Read ? 1 : 0));
                cmd.Parameters.Add(new SqliteParameter("type", item.Type ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("title", item.Title ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("description", item.Description ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("link", item.Link ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("lastUpdated", item.LastUpdated?.ToUnixTimeMilliseconds()));
                cmd.Parameters.Add(new SqliteParameter("publishingDate", item.PublishingDate?.ToUnixTimeMilliseconds() ?? 0));
                cmd.Parameters.Add(new SqliteParameter("author", item.Author ?? string.Empty));
                cmd.Parameters.Add(new SqliteParameter("categories", item.Categories != null ? string.Join(',', item.Categories) : string.Empty));
                cmd.Parameters.Add(new SqliteParameter("content", item.Content ?? string.Empty));
                if (dbc.State != ConnectionState.Open)
                    dbc.Open();
                int affected = await cmd.ExecuteNonQueryAsync();
                if (affected == 0)
					Log.Verbose("Could not set feed item: {FeedLink}", item.Link);
                else
				    result += affected;
			}
            transaction.Commit();
            return result; // Return the amount affected rows.
        }
        public async Task<bool> RemoveFeedItemAsync(FeedItemModel itemModel)
        {
            bool result = false;
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand($"DELETE FROM {_feedItemTable} WHERE id=@id", dbc)
            {
                Parameters =
                {
                    new SqliteParameter("id", itemModel.Id)
                }
            };
            int affected = await cmd.ExecuteNonQueryAsync();
            if (affected != 0)
                result = true;
            return result;
        }
        public async Task<GroupModel?> GetGroupFromFeedItemAsync(FeedItemModel feedItem)
        {
            GroupModel? result = null;
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            await using SqliteCommand cmd = new SqliteCommand($"SELECT * FROM {_groupTable} WHERE id=(SELECT group_id FROM {_feedTable} WHERE id=@fId)", dbc)
            {
                Parameters =
                {
                    new SqliteParameter ("fId", feedItem.Id)
                }
            };
            await using SqliteDataReader reader = await cmd.ExecuteReaderAsync();
            HashSet<GroupModel>? groups = null;
            if (reader.Read())
                groups = await GetGroupsAsync(reader["group_id"].ToString());
            if (groups != null && groups.Any())
                result = groups.FirstOrDefault();
            return result;
        }
        private async Task<FeedModel> ReaderToFeedModel(SqliteDataReader reader)
        {
            FeedModel fetchedFeed = new FeedModel(reader["url"].ToString())
            {
                Id = reader["id"].ToString(),
                Title = reader["title"].ToString(),
                GroupId = reader["group_id"].ToString(),
                FeedType = reader["feed_type"].ToString(),
                Description = reader["description"].ToString(),
                Language = reader["language"].ToString(),
                Copyright = reader["copyright"].ToString(),
                DateAdded = DateTimeOffset.FromUnixTimeMilliseconds(long.TryParse(reader["date_added"].ToString(), out long parsedVal) ? parsedVal : 0),
                LastUpdated = DateTimeOffset.FromUnixTimeMilliseconds(long.TryParse(reader["last_updated"].ToString(), out long lastUpdated) ? lastUpdated : 0),
                ImageUrl = reader["image_url"].ToString(),
                OriginalDocument = reader["original_document"].ToString()
            };
            var groupFetch = await GetGroupsAsync(fetchedFeed.GroupId);
            if (groupFetch.Any())
                fetchedFeed.Group = groupFetch.First();
            else
                Log.Warning("Could not get group from feed: {FeedId}", fetchedFeed.Id);
            return fetchedFeed;
        }
        private async void InitializeDb()
        {
            Log.Verbose("Checking database...");
            HashSet<string> failed = new HashSet<string>();
            await using SqliteConnection dbc = new SqliteConnection(_connectionString);
            dbc.Open();
            Log.Verbose("Checking table: {Table}", _groupTable);
            var queryResponse = await dbc.QueryAsync($"CREATE TABLE IF NOT EXISTS {_groupTable} (name STRING NOT NULL, hex_color STRING NOT NULL, icon STRING, id STRING PRIMARY KEY)");
            if (queryResponse.Any()) failed.Add("category_data");
			
			Log.Verbose("Checking table: {Table}", _feedTable);
			queryResponse = await dbc.QueryAsync($"CREATE TABLE IF NOT EXISTS {_feedTable} (id STRING PRIMARY KEY, url STRING NOT NULL, title STRING, group_id STRING, feed_type STRING, description STRING, language STRING, copyright STRING, date_added INT, last_updated INT, image_url STRING, original_document STRING)");
            if (queryResponse.Any()) failed.Add("feed_data");

            Log.Verbose("Checking table: {Table}", _feedItemTable);
            queryResponse = await dbc.QueryAsync($"CREATE TABLE IF NOT EXISTS {_feedItemTable} (id STRING PRIMARY KEY, feed_id STRING, read INT, title STRING, description STRING, link STRING, last_updated INT, publishing_date INT, author STRING, categories STRING, content STRING)");
            if (queryResponse.Any()) failed.Add("feed_item_data");
            
            if (failed.Any())
            {
                var joined = string.Join(',', failed);
                Log.Error("Failed to initialize table(s): {TableNames}", joined);
            }
            else
                Log.Verbose("Checking database done!");
        }
        public void Dispose()
        {
        }
    }
}