import { Types } from 'mongoose';
import MemoryTagModel from '../../models/MemoryTag';
import {
  CreateMemoryTagRequest,
  UpdateMemoryTagRequest,
  MemoryTagResponse,
  MemoryTagListResponse,
} from '../../types';
import QRCodeModel from '../../models/QrCode';
import * as QrCodeRepository from '../qr-code/QrCodeRepositry';

export class MemoryTagService {
  /**
   * Helper method to convert MongoDB document to response format
   */
  private static convertToResponse(doc: any): MemoryTagResponse {
    return {
      ...doc,
      _id: doc._id.toString(),
      userId: doc.userId.toString(),
    };
  }

  /**
   * Create a new memory tag
   */
  public static async createMemoryTag(
    userId: string,
    data: CreateMemoryTagRequest
  ): Promise<MemoryTagResponse> {
    try {
      const memoryTag = new MemoryTagModel({
        ...data,
        userId: new Types.ObjectId(userId),
      });

      const savedMemoryTag = await memoryTag.save();
      return this.convertToResponse(savedMemoryTag.toObject());
    } catch (error) {
      console.error('Error creating memory tag:', error);
      throw new Error('Failed to create memory tag');
    }
  }

  /**
   * Get memory tags for a user with pagination
   */
  public static async getMemoryTags(
    userId: string,
    page: number = 1,
    limit: number = 10,
    search?: string
  ) {
    try {
      const skip = (page - 1) * limit;

      // Build search query
      const matchQuery: any = {
        created_by: new Types.ObjectId(userId),
        type: 'MEMORY_TAG',
        isDelete: false,
      };

      if (search) {
        matchQuery.$or = [
          { item_name: { $regex: search, $options: 'i' } },
          { item_description: { $regex: search, $options: 'i' } },
        ];
      }

      // Fetch memory tags first (no Promise.all)
      const memoryTags = await QrCodeRepository.getQrCodesWithAggregation(matchQuery, skip, limit);

      // Then fetch the total count separately
      const total = await QrCodeRepository.countQrCodesWithQuery(matchQuery);

      const totalPages = Math.ceil(total / limit);

      return {
        memoryTags,
        pagination: {
          currentPage: page,
          totalPages,
          totalItems: total,
          itemsPerPage: limit,
          hasNextPage: page < totalPages,
          hasPrevPage: page > 1,
        },
      };
    } catch (error) {
      console.error('Error fetching memory tags:', error);
      throw new Error('Failed to fetch memory tags');
    }
  }


  /**
   * Get a memory tag by ID
   */
  public static async getMemoryTagById(
    memoryTagId: string,
    userId?: string
  ): Promise<MemoryTagResponse | null> {
    try {
      const query: any = { _id: new Types.ObjectId(memoryTagId) };

      if (userId) {
        query.userId = new Types.ObjectId(userId);
      }

      const memoryTag = await MemoryTagModel.findOne(query).lean();
      return memoryTag ? this.convertToResponse(memoryTag) : null;
    } catch (error) {
      console.error('Error fetching memory tag by ID:', error);
      throw new Error('Failed to fetch memory tag');
    }
  }

  /**
   * Update a memory tag
   */
  public static async updateMemoryTag(
    memoryTagId: string,
    userId: string,
    data: UpdateMemoryTagRequest
  ): Promise<MemoryTagResponse | null> {
    try {
      const updatedMemoryTag = await MemoryTagModel.findOneAndUpdate(
        {
          _id: new Types.ObjectId(memoryTagId),
          userId: new Types.ObjectId(userId),
        },
        { $set: data },
        { new: true, runValidators: true }
      ).lean();

      return updatedMemoryTag ? this.convertToResponse(updatedMemoryTag) : null;
    } catch (error) {
      console.error('Error updating memory tag:', error);
      throw new Error('Failed to update memory tag');
    }
  }

  /**
   * Delete a memory tag
   */
  public static async deleteMemoryTag(
    memoryTagId: string,
    userId: string
  ): Promise<boolean> {
    try {
      const result = await MemoryTagModel.findOneAndDelete({
        _id: new Types.ObjectId(memoryTagId),
        userId: new Types.ObjectId(userId),
      });

      return result !== null;
    } catch (error) {
      console.error('Error deleting memory tag:', error);
      throw new Error('Failed to delete memory tag');
    }
  }

  /**
   * Get memory tags by category
   */
  public static async getMemoryTagsByCategory(
    userId: string,
    category: string,
    page: number = 1,
    limit: number = 10
  ): Promise<MemoryTagListResponse> {
    try {
      const skip = (page - 1) * limit;

      const query = {
        userId: new Types.ObjectId(userId),
        category: { $regex: category, $options: 'i' },
      };

      const [memoryTags, total] = await Promise.all([
        MemoryTagModel.find(query)
          .sort({ createdAt: -1 })
          .skip(skip)
          .limit(limit)
          .lean(),
        MemoryTagModel.countDocuments(query),
      ]);

      const totalPages = Math.ceil(total / limit);

      return {
        memoryTags: memoryTags.map(tag => this.convertToResponse(tag)),
        pagination: {
          currentPage: page,
          totalPages,
          totalItems: total,
          itemsPerPage: limit,
          hasNextPage: page < totalPages,
          hasPrevPage: page > 1,
        },
      };
    } catch (error) {
      console.error('Error fetching memory tags by category:', error);
      throw new Error('Failed to fetch memory tags by category');
    }
  }

  /**
   * Get memory tags shared with caregiver
   */
  public static async getSharedMemoryTags(
    userId: string,
    page: number = 1,
    limit: number = 10
  ): Promise<MemoryTagListResponse> {
    try {
      const skip = (page - 1) * limit;

      const query = {
        userId: new Types.ObjectId(userId),
        shareWithCareGiver: true,
      };

      const [memoryTags, total] = await Promise.all([
        MemoryTagModel.find(query)
          .sort({ createdAt: -1 })
          .skip(skip)
          .limit(limit)
          .lean(),
        MemoryTagModel.countDocuments(query),
      ]);

      const totalPages = Math.ceil(total / limit);

      return {
        memoryTags: memoryTags.map(tag => this.convertToResponse(tag)),
        pagination: {
          currentPage: page,
          totalPages,
          totalItems: total,
          itemsPerPage: limit,
          hasNextPage: page < totalPages,
          hasPrevPage: page > 1,
        },
      };
    } catch (error) {
      console.error('Error fetching shared memory tags:', error);
      throw new Error('Failed to fetch shared memory tags');
    }
  }

  /**
   * Toggle share with caregiver status
   */
  public static async toggleShareWithCaregiver(
    memoryTagId: string,
    userId: string
  ): Promise<MemoryTagResponse | null> {
    try {
      const memoryTag = await MemoryTagModel.findOne({
        _id: new Types.ObjectId(memoryTagId),
        userId: new Types.ObjectId(userId),
      });

      if (!memoryTag) {
        return null;
      }

      memoryTag.shareWithCareGiver = !memoryTag.shareWithCareGiver;
      await memoryTag.save();

      return this.convertToResponse(memoryTag.toObject());
    } catch (error) {
      console.error('Error toggling share with caregiver:', error);
      throw new Error('Failed to toggle share with caregiver');
    }
  }

  /**
   * Get memory tags statistics for a user
   */
  public static async getMemoryTagStats(userId: string): Promise<{
    total: number;
    byCategory: { [key: string]: number };
    shared: number;
    withNotes: number;
  }> {
    try {
      const [total, byCategory, shared, withNotes] = await Promise.all([
        MemoryTagModel.countDocuments({ userId: new Types.ObjectId(userId) }),
        MemoryTagModel.aggregate([
          { $match: { userId: new Types.ObjectId(userId) } },
          { $group: { _id: '$category', count: { $sum: 1 } } },
        ]),
        MemoryTagModel.countDocuments({
          userId: new Types.ObjectId(userId),
          shareWithCareGiver: true,
        }),
        MemoryTagModel.countDocuments({
          userId: new Types.ObjectId(userId),
          notes: true,
        }),
      ]);

      const categoryStats: { [key: string]: number } = {};
      byCategory.forEach((item: any) => {
        categoryStats[item._id] = item.count;
      });

      return {
        total,
        byCategory: categoryStats,
        shared,
        withNotes,
      };
    } catch (error) {
      console.error('Error fetching memory tag stats:', error);
      throw new Error('Failed to fetch memory tag statistics');
    }
  }
}
