using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Dapper;
using Robware.Blog;
using Robware.Data.States;

namespace Robware.Data
{
	public class BlogRepository : IBlogRepository
	{
		private readonly IDatabaseProvider _dbProvider;

		public BlogRepository(IDatabaseProvider dbProvider) => _dbProvider = dbProvider;

		private static BlogPost MapBlogPost(BlogPostState state) => new BlogPost {
			Id = state.Post_Id,
			Title = state.Post_Title,
			Content = state.Post_Content,
			Timestamp = state.Post_Timestamp,
			Draft = state.Post_Draft,
			Url = state.Post_Url,
			UserId = state.User_Id
		};

		public async Task<BlogPost> GetPostByUrlAsync(string url) {
			const string query = "SELECT * FROM blog_posts WHERE post_url=@url AND post_deleted=0";
			using (var connection = _dbProvider.NewConnection()) {
				connection.Open();
				var result = await connection.QueryAsync<BlogPostState>(query, new{url});
				return MapBlogPost(result.First());
			}
		}

		public async Task<IEnumerable<BlogPost>> GetLatestPostsAsync(int limit, int offset = 0) {
			const string query = "SELECT * FROM blog_posts WHERE post_content<>'' AND post_deleted=0 ORDER BY post_timestamp DESC LIMIT @offset,@limit";
			using (var connection = _dbProvider.NewConnection()) {
				connection.Open();
				var results = await connection.QueryAsync<BlogPostState>(query, new{limit, offset});
				return results.Select(MapBlogPost);
			}
		}

		public async Task<BlogPost> GetLatestPostAsync() => (await GetLatestPostsAsync(1)).First();

		public async Task<int> GetCountAsync()
		{
			var query="SELECT COUNT(*) FROM blog_posts WHERE post_content<>'' AND post_deleted=0";
			using(var connection = _dbProvider.NewConnection()) {
				connection.Open();
				var result = await connection.QueryAsync<int>(query);
				return result.First();
			}
		}

		public async Task<BlogPost> GetPostByIdAsync(int id) {
			const string query = "SELECT * FROM blog_posts WHERE post_id=@id AND post_deleted=0";
			using (var connection = _dbProvider.NewConnection()) {
				connection.Open();
				var result = await connection.QueryAsync<BlogPostState>(query, new {id});
				return MapBlogPost(result.First());
			}
		}

		public async Task<BlogPost> SavePost(BlogPost post) {
			const string newPostQuery = "INSERT INTO blog_posts (post_title, post_content, post_draft, post_url) VALUES (@title, @content, @draft, @url); SELECT CAST(LAST_INSERT_ID() as int)";
			const string updatePostQuery = "UPDATE blog_posts SET post_id = @id, post_title = @title, post_content = @content, post_draft = @draft, post_url = @url WHERE post_id = @id ";

			var newPost = post.Id == 0;

			using (var connection = _dbProvider.NewConnection()) {
				connection.Open();
				var result = await connection.QueryAsync<int>(newPost ? newPostQuery : updatePostQuery, post);
				return newPost ? await GetPostByIdAsync(result.Single()) : post;
			}
		}

		public async Task<IEnumerable<BlogPost>> GetAllPostsAsync() {
			const string query = "SELECT * FROM blog_posts WHERE post_deleted=0";

			using (var connection = _dbProvider.NewConnection()) {
				connection.Open();
				var result = await connection.QueryAsync<BlogPostState>(query);
				return result.Select(MapBlogPost);
			}
		}

		public async Task DeletePostAsync(int id) {
			const string query = "UPDATE blog_posts SET post_deleted=1 WHERE post_id=@id";

			using (var connection = _dbProvider.NewConnection()) {
				connection.Open();
				await connection.ExecuteAsync(query, new {id});
			}
		}
	}
}