using Blog3000.Shared;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Caching.Memory;
using System.Text;
using System.IO;
using Microsoft.AspNetCore.StaticFiles;

namespace Blog3000.Server.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class BlogPostsController : ControllerBase
    {
    
        private readonly ILogger<BlogPostsController> logger;     
        private readonly BlogPostRepo blogPostRepo;

        public BlogPostsController(ILogger<BlogPostsController> logger, BlogPostRepo blogPostRepo)
        {
            this.logger = logger;
            this.blogPostRepo = blogPostRepo;            
        }




        [HttpGet]
        public ActionResult<IEnumerable<BlogPostHeader>> GetHeaders()
        {
            logger.LogInformation($"BlogPosts|{HttpContext.Connection.RemoteIpAddress}|GetHeaders");

            var res = blogPostRepo.GetHeaders();

            return new ActionResult<IEnumerable<BlogPostHeader>>(res.Where(s => "PUBLIC".Equals(s.Access)));
        }



        [HttpGet("{id}")]
        public ActionResult<BlogPost> GetPost(String id)
        {
            logger.LogInformation($"BlogPosts|{HttpContext.Connection.RemoteIpAddress}|GetHeader|{id}");

            if (String.IsNullOrWhiteSpace(id))
            {
                return BadRequest("id");
            }
            var posts = blogPostRepo.GetHeaders();

            // Check accessibilty
            var post = posts
                .Where(s => "PUBLIC".Equals(s.Access))
                .Where(s => id.Equals(s.Id))
                .FirstOrDefault();

            if (post == null)
            {
                return NotFound("id");
            }

            var res = blogPostRepo.GetText(post);
            if (res == null)
            {
                return NotFound("id/text");
            }

            var bpt = BlogPost.FromBlogPost(post);
            bpt.Text = res;

            return bpt;
        }





        [HttpGet("{id}/imgref/{imgRef}")]
        public ActionResult<byte[]> GetImage(String id, String imgRef)
        {
            logger.LogInformation($"BlogPosts|{HttpContext.Connection.RemoteIpAddress}|GetImage|{id}|{imgRef}");

            if (String.IsNullOrWhiteSpace(id))
            {
                return BadRequest("id");
            }

            if (String.IsNullOrWhiteSpace(imgRef))
            {
                return BadRequest("imgRef");
            }
            var posts = blogPostRepo.GetHeaders();

            // Check accessibilty
            var post = posts
                .Where(s => "PUBLIC".Equals(s.Access))
                .Where(s => id.Equals(s.Id))
                .FirstOrDefault();

            if (post == null)
            {
                return NotFound("id");
            }

            var pp = blogPostRepo.GetImgPath(post, imgRef);

            if (pp == null)
            {
                return NotFound("id/ref");
            }
            var fn = System.IO.Path.GetFileName(pp)?.ToLowerInvariant();
            //sring mimeType = MimeMapping.GetMimeMapping(fileName) ?? "image/jpeg";
            string mime;
            new FileExtensionContentTypeProvider().TryGetContentType(fn, out mime);

            //var ext = System.IO.Path.GetExtension(pp)?.ToLowerInvariant();
            //var mime = "image/jpeg";
            //if ((ext != null) && !(".jpg".Equals(ext))) {
            //    mime = "image/"+ext.Substring(1);
            //}
            return PhysicalFile(pp, $"{mime}");
        }



        [HttpGet("search")]
        public async Task<ActionResult<List<string>>> SearchAsync(string searchTerm, int startIdx=0, int pageMaxSize=20, bool findLastPage=false)
        {
            logger.LogInformation($"BlogPosts|{HttpContext.Connection.RemoteIpAddress}|Search|{searchTerm}");

            async IAsyncEnumerable<BlogPostHeader>  GetHeaders()
            {
                foreach(var p in blogPostRepo.GetHeaders())
                {
                    await Task.Yield();
                    yield return p;
                }
            }

            async IAsyncEnumerable<BlogPost> GetPosts()
            {
                foreach (var p in blogPostRepo.GetHeaders())
                {
                    
                    await Task.Yield();
                    var bt = BlogPost.FromBlogPost(p);
                    bt.Text = blogPostRepo.GetText(p);
                    yield return bt;
                }
            }

            var bps = new BlogPostSearch(() => GetPosts(), () => GetHeaders(), searchTerm);
            var posts = await bps.ExecAsync(startIdx, pageMaxSize, findLastPage);
            return posts.Select(c => c.Id).ToList();            
        }
    }
}