package com.qf.myafterprojecy.service;

import com.qf.myafterprojecy.config.ResponseMessage;
import com.qf.myafterprojecy.pojo.Message;
import com.qf.myafterprojecy.pojo.dto.MessageDto;
import com.qf.myafterprojecy.repository.MessageRepository;
import com.qf.myafterprojecy.service.imp.IMessageService;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.Date;
import java.util.List;
import java.util.Optional;

import org.springframework.transaction.annotation.Transactional;

@Service
public class MessageService implements IMessageService {

    private static final Logger logger = LoggerFactory.getLogger(MessageService.class);

    @Autowired
    private MessageRepository messageRepository;

    @Override
    public ResponseMessage<Iterable<Message>> getAllMessages() {
        try {
            logger.info("查询所有消息");
            Iterable<Message> messages = messageRepository.findAll();
            return ResponseMessage.success(messages, "查询成功");
        } catch (DataAccessException e) {
            logger.error("查询所有消息失败", e);
            return ResponseMessage.error("查询消息失败：" + e.getMessage());
        }
    }

    @Override
    public ResponseMessage<Message> getMessageById(Integer id) {
        if (id == null || id <= 0) {
            logger.warn("获取消息时ID无效: {}", id);
            return ResponseMessage.badRequest("消息ID无效");
        }

        try {
            logger.info("根据ID查询消息: {}", id);
            Optional<Message> messageOptional = messageRepository.findById(id);
            if (messageOptional.isPresent()) {
                return ResponseMessage.success(messageOptional.get(), "查询成功");
            } else {
                logger.warn("未找到ID为{}的消息", id);
                return ResponseMessage.notFound("未找到指定消息");
            }
        } catch (DataAccessException e) {
            logger.error("查询消息失败: {}", id, e);
            return ResponseMessage.error("查询消息失败：" + e.getMessage());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseMessage<Message> saveMessage(MessageDto messageDto) {
        // 参数校验
        if (messageDto == null) {
            logger.warn("保存消息时参数为空");
            throw new IllegalArgumentException("MessageDto cannot be null");
        }

        // 业务逻辑校验
        if (StringUtils.isEmpty(messageDto.getContent())) {
            logger.warn("保存消息时内容为空");
            throw new IllegalArgumentException("Message content cannot be empty");
        }

        if (StringUtils.isEmpty(messageDto.getNickname())) {
            logger.warn("保存消息时昵称为空");
            throw new IllegalArgumentException("Message nickname cannot be empty");
        }

        // 调用Repository保存数据
        try {
            logger.info("保存消息: {}", messageDto.getNickname());
            Message message = new Message();
            BeanUtils.copyProperties(messageDto, message);
            message.setCreatedAt(new Date()); // 设置创建时间
            message.setLikes(0); // 设置点赞数初始值为0

            // 如果是回复，确保parentid有效
            if (messageDto.getParentid() != null && messageDto.getParentid() > 0) {
                if (!messageRepository.existsById(messageDto.getParentid())) {
                    logger.warn("回复的父消息不存在: {}", messageDto.getParentid());
                    return ResponseMessage.notFound("回复的父消息不存在");
                }
            }
            Message savedMessage = messageRepository.save(message);
            logger.info("消息保存成功: {}", savedMessage.getMessageid());
            return ResponseMessage.save(true, savedMessage);
        } catch (DataAccessException e) {
            logger.error("保存消息失败", e);
            return ResponseMessage.error("保存消息失败：" + e.getMessage());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseMessage<Message> deleteMessage(Integer id) {
        if (id == null || id <= 0) {
            logger.warn("删除消息时ID无效: {}", id);
            return ResponseMessage.badRequest("消息ID无效");
        }

        try {
            logger.info("删除消息: {}", id);
            if (messageRepository.existsById(id)) {
                messageRepository.deleteById(id);
                // 同时删除该消息的所有回复
                List<Message> replies = messageRepository.findByParentid(id);
                if (replies != null && !replies.isEmpty()) {
                    messageRepository.deleteAll(replies);
                    logger.info("同时删除了{}条回复消息", replies.size());
                }
                logger.info("消息删除成功: {}", id);
                return ResponseMessage.delete(true);
            } else {
                logger.warn("未找到要删除的消息: {}", id);
                return ResponseMessage.notFound("未找到要删除的消息");
            }
        } catch (DataAccessException e) {
            logger.error("删除消息失败: {}", id, e);
            return ResponseMessage.error("删除消息失败：" + e.getMessage());
        }
    }

    @Override
    public ResponseMessage<List<Message>> getMessagesByArticleId(Integer articleId) {
        if (articleId == null || articleId <= 0) {
            logger.warn("根据文章ID查询消息时ID无效: {}", articleId);
            return ResponseMessage.badRequest("文章ID无效");
        }

        try {
            logger.info("根据文章ID查询消息: {}", articleId);
            List<Message> messages = messageRepository.findByArticleid(articleId);
            return ResponseMessage.success(messages, "查询成功");
        } catch (DataAccessException e) {
            logger.error("根据文章ID查询消息失败: {}", articleId, e);
            return ResponseMessage.error("查询消息失败：" + e.getMessage());
        }
    }

    @Override
    public ResponseMessage<List<Message>> getRootMessages() {
        try {
            logger.info("查询所有根消息");
            List<Message> messages = messageRepository.findByParentidIsNull();
            return ResponseMessage.success(messages, "查询成功");
        } catch (DataAccessException e) {
            logger.error("查询根消息失败", e);
            return ResponseMessage.error("查询消息失败：" + e.getMessage());
        }
    }

    @Override
    public ResponseMessage<List<Message>> getRepliesByParentId(Integer parentId) {
        if (parentId == null || parentId <= 0) {
            logger.warn("根据父消息ID查询回复时ID无效: {}", parentId);
            return ResponseMessage.badRequest("父消息ID无效");
        }
        try {
            logger.info("根据父消息ID查询回复: {}", parentId);
            List<Message> replies = messageRepository.findByParentid(parentId);
            return ResponseMessage.success(replies, "查询成功");
        } catch (DataAccessException e) {
            logger.error("查询回复消息失败: {}", parentId, e);
            return ResponseMessage.error("查询消息失败：" + e.getMessage());
        }
    }

    // 点赞数增加
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseMessage<Message> likeMessage(Integer id) {
        if (id == null || id <= 0) {
            logger.warn("点赞消息时ID无效: {}", id);
            return ResponseMessage.badRequest("消息ID无效");
        }
        try {
            logger.info("点赞消息: {}", id);
            messageRepository.incrementLikes(id);
            Message likedMessage = messageRepository.findById(id).orElse(null);
            return ResponseMessage.success(likedMessage, "点赞成功");
        } catch (DataAccessException e) {
            logger.error("点赞消息失败: {}", id, e);
            return ResponseMessage.error("点赞消息失败：" + e.getMessage());
        }
    }

    @Override
    public ResponseMessage<List<Message>> searchMessagesByNickname(String nickname) {
        if (StringUtils.isEmpty(nickname)) {
            logger.warn("根据昵称查询消息时昵称为空");
            return ResponseMessage.badRequest("昵称不能为空");
        }

        try {
            logger.info("根据昵称查询消息: {}", nickname);
            List<Message> messages = messageRepository.findByNicknameContaining(nickname);
            return ResponseMessage.success(messages, "查询成功");
        } catch (DataAccessException e) {
            logger.error("根据昵称查询消息失败: {}", nickname, e);
            return ResponseMessage.error("查询消息失败：" + e.getMessage());
        }
    }

    // 删除所有评论
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseMessage<Void> deleteAllMessages() {
        try {
            logger.info("删除所有消息");
            messageRepository.deleteAll();
            return ResponseMessage.delete(true);
        } catch (DataAccessException e) {
            logger.error("删除所有消息失败", e);
            return ResponseMessage.error("删除消息失败：" + e.getMessage());
        }
    }

    @Override
    public ResponseMessage<Long> getMessageCountByArticleId(Integer articleId) {
        if (articleId == null || articleId <= 0) {
            logger.warn("获取文章评论数量时ID无效: {}", articleId);
            return ResponseMessage.badRequest("文章ID无效");
        }

        try {
            logger.info("获取文章评论数量: {}", articleId);
            Long count = messageRepository.countByArticleId(articleId);
            return ResponseMessage.success(count, "查询成功");
        } catch (DataAccessException e) {
            logger.error("获取文章评论数量失败: {}", articleId, e);
            return ResponseMessage.error("查询评论数量失败：" + e.getMessage());
        }
    }
}