import { Request, Response, NextFunction } from 'express';
import { MemoryTagService } from './memory.service';
import { MemoryTagValidation } from '../../validations/memoryTagValidation';
import { ValidationUtils } from '../../validations';
import { CreateMemoryTagRequest, UpdateMemoryTagRequest } from '../../types';
import { UniResponse } from '../../lib/UniResponse';
import { asyncHandler } from '../../utils/asyncHandler';

// Extend Request interface to include user
interface AuthenticatedRequest extends Request {
  user?: {
    userId: string;
    email: string;
    role: string;
  };
}

export class MemoryTagController {
  public static createMemoryTag = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate request body
      const validation = MemoryTagValidation.createMemoryTag.validate(req.body);
      if (!ValidationUtils.isValidationSuccess(validation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(validation.error),
              validation.error,
              400
            )
          );
        return;
      }

      const data: CreateMemoryTagRequest = ValidationUtils.getValidatedData(validation);
      const memoryTag = await MemoryTagService.createMemoryTag(userId, data);

      res
        .status(201)
        .json(UniResponse.Success('Memory tag created successfully', memoryTag, 201));
    }
  );

  public static getMemoryTags = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate query parameters
      const validation = MemoryTagValidation.getMemoryTags.validate(req.query);
      if (!ValidationUtils.isValidationSuccess(validation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(validation.error),
              validation.error,
              400
            )
          );
        return;
      }

      const { page, limit, search } = ValidationUtils.getValidatedData(validation);
      const result = await MemoryTagService.getMemoryTags(userId, page, limit, search);

      res
        .status(200)
        .json(UniResponse.Success('Memory tags retrieved successfully', result, 200));
    }
  );

  public static getMemoryTagById = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate memory tag ID
      const validation = MemoryTagValidation.objectId.validate(req.params.id);
      if (!ValidationUtils.isValidationSuccess(validation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(validation.error),
              validation.error,
              400
            )
          );
        return;
      }

      const memoryTagId = ValidationUtils.getValidatedData(validation);
      const memoryTag = await MemoryTagService.getMemoryTagById(memoryTagId, userId);

      if (!memoryTag) {
        res.status(404).json(UniResponse.Error('Memory tag not found', null, 404));
        return;
      }

      res
        .status(200)
        .json(UniResponse.Success('Memory tag retrieved successfully', memoryTag, 200));
    }
  );

  public static updateMemoryTag = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate memory tag ID
      const idValidation = MemoryTagValidation.objectId.validate(req.params.id);
      if (!ValidationUtils.isValidationSuccess(idValidation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(idValidation.error),
              idValidation.error,
              400
            )
          );
        return;
      }

      // Validate request body
      const bodyValidation = MemoryTagValidation.updateMemoryTag.validate(req.body);
      if (!ValidationUtils.isValidationSuccess(bodyValidation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(bodyValidation.error),
              bodyValidation.error,
              400
            )
          );
        return;
      }

      const memoryTagId = ValidationUtils.getValidatedData(idValidation);
      const data: UpdateMemoryTagRequest =
        ValidationUtils.getValidatedData(bodyValidation);

      const memoryTag = await MemoryTagService.updateMemoryTag(
        memoryTagId,
        userId,
        data
      );

      if (!memoryTag) {
        res.status(404).json(UniResponse.Error('Memory tag not found', null, 404));
        return;
      }

      res
        .status(200)
        .json(UniResponse.Success('Memory tag updated successfully', memoryTag, 200));
    }
  );

  public static deleteMemoryTag = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate memory tag ID
      const validation = MemoryTagValidation.objectId.validate(req.params.id);
      if (!ValidationUtils.isValidationSuccess(validation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(validation.error),
              validation.error,
              400
            )
          );
        return;
      }

      const memoryTagId = ValidationUtils.getValidatedData(validation);
      const deleted = await MemoryTagService.deleteMemoryTag(memoryTagId, userId);

      if (!deleted) {
        res.status(404).json(UniResponse.Error('Memory tag not found', null, 404));
        return;
      }

      res
        .status(200)
        .json(UniResponse.Success('Memory tag deleted successfully', undefined, 200));
    }
  );

  public static getMemoryTagsByCategory = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate query parameters
      const validation = MemoryTagValidation.categoryFilter.validate({
        ...req.query,
        category: req.params.category,
      });
      if (!ValidationUtils.isValidationSuccess(validation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(validation.error),
              validation.error,
              400
            )
          );
        return;
      }

      const { category, page, limit } = ValidationUtils.getValidatedData(validation);
      const result = await MemoryTagService.getMemoryTagsByCategory(
        userId,
        category,
        page,
        limit
      );

      res
        .status(200)
        .json(UniResponse.Success('Memory tags retrieved successfully', result, 200));
    }
  );

  public static getSharedMemoryTags = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate query parameters
      const validation = MemoryTagValidation.getMemoryTags.validate(req.query);
      if (!ValidationUtils.isValidationSuccess(validation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(validation.error),
              validation.error,
              400
            )
          );
        return;
      }

      const { page, limit } = ValidationUtils.getValidatedData(validation);
      const result = await MemoryTagService.getSharedMemoryTags(userId, page, limit);

      res
        .status(200)
        .json(
          UniResponse.Success('Shared memory tags retrieved successfully', result, 200)
        );
    }
  );

  public static toggleShareWithCaregiver = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Validate memory tag ID
      const validation = MemoryTagValidation.objectId.validate(req.params.id);
      if (!ValidationUtils.isValidationSuccess(validation)) {
        res
          .status(400)
          .json(
            UniResponse.Error(
              ValidationUtils.formatValidationError(validation.error),
              validation.error,
              400
            )
          );
        return;
      }

      const memoryTagId = ValidationUtils.getValidatedData(validation);
      const memoryTag = await MemoryTagService.toggleShareWithCaregiver(
        memoryTagId,
        userId
      );

      if (!memoryTag) {
        res.status(404).json(UniResponse.Error('Memory tag not found', null, 404));
        return;
      }

      const action = memoryTag.shareWithCareGiver ? 'enabled' : 'disabled';
      res
        .status(200)
        .json(
          UniResponse.Success(
            `Share with caregiver ${action} successfully`,
            memoryTag,
            200
          )
        );
    }
  );

  public static getMemoryTagStats = asyncHandler(
    async (
      req: AuthenticatedRequest,
      res: Response,
      next: NextFunction
    ): Promise<void> => {
      const userId = req.user?.userId;
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      const stats = await MemoryTagService.getMemoryTagStats(userId);

      res
        .status(200)
        .json(
          UniResponse.Success(
            'Memory tag statistics retrieved successfully',
            stats,
            200
          )
        );
    }
  );
}
