import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Message } from './entities';
import { CreateMessageDto, MessagesQueryDto } from './dto';

@Injectable()
export class MessagesService {
  constructor(
    @InjectRepository(Message)
    private messagesRepository: Repository<Message>,
  ) {}

  async create(createMessageDto: CreateMessageDto): Promise<Message> {
    const message = this.messagesRepository.create({
      name: createMessageDto.name,
      email: createMessageDto.email,
      subject: createMessageDto.subject,
      message: createMessageDto.message,
      isRead: false,
    });

    return this.messagesRepository.save(message);
  }

  async findAll(
    query: MessagesQueryDto,
  ): Promise<{ messages: Message[]; total: number; page: number; limit: number; unreadCount: number }> {
    const { page = 1, limit = 10, isRead } = query;

    const queryBuilder = this.messagesRepository.createQueryBuilder('message');

    // Filter by read status if specified
    if (isRead !== undefined) {
      queryBuilder.andWhere('message.isRead = :isRead', { isRead });
    }

    // Sort by createdAt (newest first)
    queryBuilder.orderBy('message.createdAt', 'DESC');

    // Get total count
    const total = await queryBuilder.getCount();

    // Pagination
    queryBuilder.skip((page - 1) * limit).take(limit);

    const messages = await queryBuilder.getMany();

    // Get unread count
    const unreadCount = await this.messagesRepository.count({
      where: { isRead: false },
    });

    return {
      messages,
      total,
      page,
      limit,
      unreadCount,
    };
  }

  async findOne(id: string): Promise<Message> {
    const message = await this.messagesRepository.findOne({ where: { id } });
    if (!message) {
      throw new NotFoundException(`Message with ID ${id} not found`);
    }

    // Mark as read when fetched by ID
    if (!message.isRead) {
      message.isRead = true;
      await this.messagesRepository.save(message);
    }

    return message;
  }

  async markAsRead(id: string): Promise<Message> {
    const message = await this.findOneWithoutMarkingRead(id);
    message.isRead = true;
    return this.messagesRepository.save(message);
  }

  async markAsUnread(id: string): Promise<Message> {
    const message = await this.findOneWithoutMarkingRead(id);
    message.isRead = false;
    return this.messagesRepository.save(message);
  }

  async remove(id: string): Promise<void> {
    const message = await this.findOneWithoutMarkingRead(id);
    await this.messagesRepository.remove(message);
  }

  async getUnreadCount(): Promise<number> {
    return this.messagesRepository.count({ where: { isRead: false } });
  }

  private async findOneWithoutMarkingRead(id: string): Promise<Message> {
    const message = await this.messagesRepository.findOne({ where: { id } });
    if (!message) {
      throw new NotFoundException(`Message with ID ${id} not found`);
    }
    return message;
  }
}