import { Injectable,HttpException,HttpStatus, Res } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, Like, Not } from 'typeorm';
import { classToPlain } from 'class-transformer';
import { responseMessages } from '../../messages/response-messages';
import { emailMessages } from '../../messages/email-messages';
import { IndustriesRepository } from './industries.repository';
import * as bcrypt from 'bcryptjs';
import { HttpService } from '@nestjs/axios';
import { Constants } from '../../common/constants';
import { JwtService } from '@nestjs/jwt';
const moment = require('moment-timezone');

// Entities Files
import { UserRoles, Users } from "../../entities/users.entity";
import { Industries } from "../../entities/industries.entity";

// DTO Files
import { CreateDto } from './dtos/create.dto';
import { ListQueryDto } from './dtos/list-query.dto';

@Injectable()
export class IndustriesService {

    constructor(
        private industriesRepository: IndustriesRepository,

        @InjectRepository(Users)
        private Users: Repository<Users>,

        @InjectRepository(Industries)
        private Industries: Repository<Industries>,

    ) {}

    async create(request : CreateDto)
    {
        request['slug'] = request.title.trim().toLowerCase().replace(/\s+/g, '_');

        const existsInd = await this.Industries.findOne({where:[ {slug : request['slug']}]});
        if(existsInd){
            throw  new HttpException(responseMessages.en.industries.already_exists,HttpStatus.NOT_FOUND);
        }

        request['title'] = request.title.trim();
        await this.industriesRepository.createData(request);

        return;
    }

    async list(queryParam : any)
    {
        const page = queryParam.page - 1;
        const pageSize = queryParam.per_page ? queryParam.per_page : Constants.industries_list;
        const offset = page * pageSize;
        const nextPage = page + 1;
        const nextOffset = nextPage * pageSize;
        const bopType = queryParam.type;

        let sortByArr = {
            created_at : 'industries.created_at',
            title : 'industries.title',
        };

        let sort_by = queryParam.sort_by || 'title';
        let sort_type = queryParam.sort || 'ASC';
        sort_by = sortByArr[sort_by];

        let query  = await this.Industries
        .createQueryBuilder('industries')
        .where('industries.deleted_at is NULL')
        .andWhere('(industries.is_active = :is_active)', { is_active: true })
        // .andWhere('(bops.users_id = :users_id)', { users_id : req_user_id })
        .select(['industries.id','industries.title','industries.slug','industries.is_active','industries.created_at'])
        .orderBy(sort_by,sort_type)

        if (queryParam.search) {
            query = query.andWhere(`(industries.title LIKE :search)`, { search: `%${queryParam.search}%` });
        }

        const [results, total] = await query.skip(offset).take(pageSize).getManyAndCount();

        return {
            data: results,
            total : total,
            hasMoreResults : (total > nextOffset) ? 1 : 0,
        }
    }



}