import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm'
import { BlogCategoryDetailEntity } from 'src/database/entity/blog-category-detail-entity/blog-category-detail-entity';
import { BlogEntity } from 'src/database/entity/blog-entity/blog-entity';
import { CategoryEntity } from 'src/database/entity/category-entity/category-entity';
import { getYearAndTimeFormat } from 'src/utils/utils';
import { ExceptionErrorMessage } from 'src/validation/exception-error';
import { DataSource, In, LessThan, MoreThan, Repository, createQueryBuilder } from 'typeorm';


@Injectable()
export class BlogService {
    constructor(@InjectRepository(BlogEntity) private readonly blogRp:Repository<BlogEntity>,
        @InjectRepository(BlogCategoryDetailEntity) private readonly blogCategoryRp:Repository<BlogCategoryDetailEntity>,
        @InjectRepository(CategoryEntity) private readonly categoryRp:Repository<CategoryEntity>,
        private datasource:DataSource
    ){}

     //Listado todos los blos
     async findAllBlogsAnalitics(slug){
        try {
            const currentTime = getYearAndTimeFormat(new Date());
            return await this.datasource.getRepository(BlogEntity).createQueryBuilder("blog")
                .innerJoinAndSelect("blog.blogDetail","blogcategorydetail")
                .innerJoinAndSelect('blogcategorydetail.category',"category")
                .where('blog.slug IN (:slug)',{slug:slug})
                .andWhere(`blog.datePublication < '${currentTime}'`)
                .getMany();
        } catch (error) {
            console.log(error)
            ExceptionErrorMessage(error);            
        }
    }  
    
    //Listado todos los blos habilitados
    async findAllBlogsPublic(){
        try {
            return await this.datasource.getRepository(BlogEntity).createQueryBuilder("blog")
                .innerJoinAndSelect("blog.blogDetail","blogcategorydetail")
                .innerJoinAndSelect('blogcategorydetail.category',"category")
                .where('blog.status=:status',{status:'active'})
                .orderBy('blog.createdAt', 'DESC')
                .getMany();
            
        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }   

    //Listado todos los blos
    async findAllBlogs(){
        try {
            return await this.datasource.getRepository(BlogEntity).createQueryBuilder("blog")
                .innerJoinAndSelect("blog.blogDetail","blogcategorydetail")
                .innerJoinAndSelect('blogcategorydetail.category',"category")
                .orderBy('blog.createdAt', 'DESC')
                .getMany();
        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }   

    //Listado todos los blos
    async findAllBlogsPublicated(){
        try {
            const currentTime = getYearAndTimeFormat(new Date());
            return await this.datasource.getRepository(BlogEntity).createQueryBuilder("blog")
                .innerJoinAndSelect("blog.blogDetail","blogcategorydetail")
                .innerJoinAndSelect('blogcategorydetail.category',"category")
                .where(`blog.datePublication < '${currentTime}'`)
                .orderBy('blog.datePublication', 'DESC')
                .getMany();
        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }   


    //Listado de los 3 ultimos blogs
    async findlastestBlogs(){
        try {
            return await this.blogRp.find({order:{createdAt:'DESC'},take:3,where:{datePublication:LessThan(new Date())}});
        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }   

    //Listado mediante slug o id
    async findlByIdOrSlug(param:any){
        try {
            const currentTime = getYearAndTimeFormat(new Date());
            console.log(currentTime)
            if(param.name=="slug")
                return await this.datasource.getRepository(BlogEntity).createQueryBuilder("blog")
                    .innerJoinAndSelect("blog.blogDetail","blogcategorydetail")
                    .innerJoinAndSelect('blogcategorydetail.category',"category")
                    .where(`blog.slug='${param.value}'`)
                    .andWhere(`blog.datePublication < '${currentTime}'`)
                    .getOne();
    
            return await this.datasource.getRepository(BlogEntity).createQueryBuilder("blog")
                .innerJoinAndSelect("blog.blogDetail","blogcategorydetail")
                .innerJoinAndSelect('blogcategorydetail.category',"category")
                .where(`blog.id=${param.value}`)
                .andWhere(`blog.datePublication < '${currentTime}'`)
                .getOne();

        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }   


    //Listado de slugs
    async getListBlogSlug(){
        try {
            return await this.blogRp.find({order:{createdAt:'DESC'},where:{datePublication:LessThan(new Date())},select:{slug:true,id:true,title:true}});

        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }  
    
    //Obtener el siguiente y previo blog
    async getPrevAndNextBlog(param:Array<number>){
        try {
            return await this.blogRp.find({order:{createdAt:'DESC'},where:{id:In([...param]) },select:{slug:true,id:true}});

        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }


    //Listado mediante el nombre de categoria o id
    async findByCategory(param:any){
        try {
            const currentTime = getYearAndTimeFormat(new Date());
            return await this.datasource.getRepository(CategoryEntity).createQueryBuilder("category")
            .innerJoinAndSelect("category.blogDetail","blogcategorydetail")
            .innerJoinAndSelect('blogcategorydetail.blog',"blog")
            .where(`category.slug='${param}'`)
            .andWhere(`category.status=true`)
            .andWhere(`blog.datePublication < '${currentTime}'`)
            .orderBy('blog.createdAt','DESC')
            .getMany();
        } catch (error) {
            console.log(error)
            ExceptionErrorMessage(error);            
        }
    }   

    //Almacenar un nuevo blog
    async saveBlog(blog:any,blogCategory:any){
        try {
            let blogCreate;
            await this.datasource.manager.transaction(async (transactionalEntityManager) => {
    
                blogCreate = await transactionalEntityManager.withRepository(this.blogRp).save(blog);
    
                await blogCategory.forEach(async blogCategoryDetail => {
                    const blogTempor = new BlogCategoryDetailEntity();
                    blogTempor.createdAt = new Date();
                    blogTempor.blog = blogCreate.id;
                    blogTempor.category = blogCategoryDetail.categoryId;
                    await transactionalEntityManager.withRepository(this.blogCategoryRp).save(blogTempor);
                });
            })
            return await this.findlByIdOrSlug({ name:"id", value:blogCreate.id});
        } catch (error) {
            ExceptionErrorMessage(error);            
        }
        
    }

    //Actualizar un blog
    async updateBlog(id:any, blog:any, blogCategory:any){
        try {
            let blogCreate;
            await this.datasource.manager.transaction(async (transactionalEntityManager) => {
                await transactionalEntityManager.withRepository(this.blogRp).update(id,blog);
    
                await transactionalEntityManager.withRepository(this.blogCategoryRp).createQueryBuilder('blogcategorydetail')
                .delete()
                .from("blogcategorydetail")
                .where("blogId = :blogId", { blogId: id })
                .execute();
    
                await blogCategory.forEach(async blogCategoryDetail => {
                    const blogTempor = new BlogCategoryDetailEntity();
                    blogTempor.createdAt = new Date();
                    blogTempor.blog = id;
                    blogTempor.category = blogCategoryDetail.categoryId;
                    await transactionalEntityManager.withRepository(this.blogCategoryRp).save(blogTempor);
                });
            })
            return await this.findlByIdOrSlug({ name:"id", value:id});
        } catch (error) {
            ExceptionErrorMessage(error);            
        }
    }

    //Borrar Blog
    async deleteBlog(id:any){
        try {
            return await this.blogRp.createQueryBuilder()
                .update(BlogEntity)
                .set({ status: false})
                .where("id = :id", { id: id})
                .execute();
        }
        catch(error){
            ExceptionErrorMessage(error);            
        }
    }
}