package com.ylx.moment.controller;

import com.alibaba.fastjson.JSON;
import com.ylx.common.core.controller.BaseController;
import com.ylx.common.core.domain.R;
import com.ylx.common.core.domain.model.WxLoginUser;
import com.ylx.common.exception.ServiceException;
import com.ylx.moment.domain.dto.MomentAuditDTO;
import com.ylx.moment.domain.dto.MomentManageQueryDTO;
import com.ylx.moment.domain.dto.MomentRecommendDTO;
import com.ylx.massage.domain.dto.PublishMomentDTO;
import com.ylx.massage.domain.dto.EditMomentDTO;
import com.ylx.moment.domain.dto.MomentListStatusDTO;
import com.ylx.moment.domain.vo.MomentAuditStatusCountVO;
import com.ylx.moment.domain.vo.MomentDetailVO;
import com.ylx.moment.domain.vo.MomentListVO;
import com.ylx.moment.domain.vo.MomentManageVO;
import com.ylx.moment.domain.vo.MomentSimpleDetailVO;
import com.ylx.moment.domain.vo.MyMomentVO;
import com.ylx.moment.service.ITechnicianMomentService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.math.BigDecimal;
import java.util.List;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

/**
 * 技师动态控制器
 */
@RestController
@RequestMapping("api/moment/v1")
@Api(tags = {"技师动态管理"})
@Slf4j
public class TechnicianMomentController extends BaseController {

    @Autowired
    private ITechnicianMomentService momentService;

    /**
     * 获取推荐动态列表
     * 展示全部的技师动态（不分地区）
     * 根据日期倒序展示，同一天的动态按照浏览量最高的优先展示
     *
     * @param pageNum  页码，默认1
     * @param pageSize 每页数量，默认10
     * @return R<List<MomentListVO>> 动态列表
     */
    /*@GetMapping("/recommended")
    @ApiOperation("获取推荐动态列表")
    public R<List<MomentListVO>> getRecommendedMoments(
            @ApiParam("页码") @RequestParam(defaultValue = "1") Integer pageNum,
            @ApiParam("每页数量") @RequestParam(defaultValue = "10") Integer pageSize) {
        try {
            List<MomentListVO> list = momentService.getRecommendedMoments(pageNum, pageSize);
            return R.ok(list);
        } catch (Exception e) {
            log.error("获取推荐动态列表失败", e);
            return R.fail("获取推荐动态列表失败：" + e.getMessage());
        }
    }*/

    /**
     * 获取同城商户动态列表
     * 展示用户同城的所有动态
     * 按照最新发布时间排序展示
     *
     * @param cityCode 城市编码
     * @param pageNum  页码，默认1
     * @param pageSize 每页数量，默认10
     * @return R<List<MomentListVO>> 动态列表
     */
    /*@GetMapping("/sameCity")
    @ApiOperation("获取同城商户动态列表")
    public R<List<MomentListVO>> getSameCityMoments(
            @ApiParam("城市编码") @RequestParam String cityCode,
            @ApiParam("页码") @RequestParam(defaultValue = "1") Integer pageNum,
            @ApiParam("每页数量") @RequestParam(defaultValue = "10") Integer pageSize) {
        try {
            if (cityCode == null || cityCode.trim().isEmpty()) {
                return R.fail("城市编码不能为空");
            }
            List<MomentListVO> list = momentService.getSameCityMoments(cityCode, pageNum, pageSize);
            return R.ok(list);
        } catch (Exception e) {
            log.error("获取同城商户动态列表失败", e);
            return R.fail("获取同城商户动态列表失败：" + e.getMessage());
        }
    }*/

    /**
     * 获取附近动态列表
     * 根据用户地理位置，展示距离10km以内的技师动态
     * 根据日期倒序展示，同一天的动态按照距离最近的优先展示
     *
     * @param latitude  用户纬度
     * @param longitude 用户经度
     * @param pageNum   页码，默认1
     * @param pageSize  每页数量，默认10
     * @return 动态列表
     */
    /*@GetMapping("/nearby")
    @ApiOperation("获取附近动态列表")
    public R<List<MomentListVO>> getNearbyMoments(
            @ApiParam("页码") @RequestParam(defaultValue = "1") Integer pageNum,
            @ApiParam("每页数量") @RequestParam(defaultValue = "10") Integer pageSize,
            @ApiParam("用户经度") @RequestParam BigDecimal longitude,
            @ApiParam("用户纬度") @RequestParam BigDecimal latitude) {
        try {
            if (latitude == null || longitude == null) {
                return R.fail("地理位置信息不能为空");
            }
            List<MomentListVO> list = momentService.getNearbyMoments(longitude, latitude, pageNum, pageSize);
            return R.ok(list);
        } catch (Exception e) {
            log.error("获取附近动态列表失败", e);
            return R.fail("获取附近动态列表失败：" + e.getMessage());
        }
    }*/

    /**
     * 获取推荐、同城、附近动态列表接口
     * 根据queryType参数决定查询类型：1-推荐,2-同城,3-附近
     *
     * @param queryType 查询类型：1-推荐,2-同城,3-附近
     * @param cityCode  城市编码（同城查询时必填）
     * @param latitude  用户纬度（附近查询时必填）
     * @param longitude 用户经度（附近查询时必填）
     * @param pageNum   页码，默认1
     * @param pageSize  每页数量，默认10
     * @return R<List<MomentListVO>> 动态列表
     */
    @GetMapping("/list")
    @ApiOperation("获取推荐、同城、附近动态列表接口")
    public R<List<MomentListVO>> getMomentList(
            @ApiParam("查询类型:1-推荐,2-同城,3-附近") @RequestParam Integer queryType,
            @ApiParam("城市编码") @RequestParam(required = false) String cityCode,
            @ApiParam("用户经度") @RequestParam(required = false) BigDecimal longitude,
            @ApiParam("用户纬度") @RequestParam(required = false) BigDecimal latitude,
            @ApiParam("页码") @RequestParam(defaultValue = "1") Integer pageNum,
            @ApiParam("每页数量") @RequestParam(defaultValue = "10") Integer pageSize) {
        try {
            List<MomentListVO> list;
            switch (queryType) {
                case 1:
                    // 推荐
                    list = momentService.getRecommendedMoments(pageNum, pageSize);
                    break;
                case 2:
                    // 同城
                    if (cityCode == null || cityCode.trim().isEmpty()) {
                        return R.fail("同城查询时城市编码不能为空");
                    }
                    list = momentService.getSameCityMoments(cityCode, pageNum, pageSize);
                    break;
                case 3:
                    // 附近
                    if (latitude == null || longitude == null) {
                        return R.fail("附近查询时地理位置信息不能为空");
                    }
                    list = momentService.getNearbyMoments(latitude, longitude, pageNum, pageSize);
                    break;
                default:
                    return R.fail("查询类型不正确，必须是1-推荐、2-同城、3-附近");
            }
            return R.ok(list);
        } catch (Exception e) {
            log.error("查询动态列表失败", e);
            return R.fail("查询动态列表失败：" + e.getMessage());
        }
    }

    /**
     * 获取动态详情（H5端）
     * 包含动态标题、技师昵称头像、技师状态、浏览量、封面图等信息
     * 每点击查看一次，浏览量+1
     *
     * @param momentId 动态ID
     * @return R<MomentDetailVO> 动态详情
     */
    @GetMapping("/detail")
    @ApiOperation("获取动态详情")
    public R<MomentDetailVO> getMomentDetail(@ApiParam("动态ID") @RequestParam Long momentId, @ApiParam("用户经度") @RequestParam(required = false) BigDecimal longitude, @ApiParam("用户纬度") @RequestParam(required = false) BigDecimal latitude) {
        try {
            if (momentId == null) {
                return R.fail("动态ID不能为空");
            }
            MomentDetailVO detail = momentService.getMomentDetail(momentId, longitude, latitude);
            return R.ok(detail);
        } catch (Exception e) {
            log.error("获取动态详情失败", e);
            return R.fail("获取动态详情失败：" + e.getMessage());
        }
    }



    /**
     * 发布动态或保存草稿
     *
     * @param dto 发布动态请求对象
     * @return R<Long> 动态ID
     */
    @PostMapping("/publish")
    @ApiOperation("发布动态或保存草稿")
    public R<Long> publishMoment(@Valid @RequestBody PublishMomentDTO dto) {
        try {
            log.info("发布动态或保存草稿的请求参数：{}", JSON.toJSONString(dto));
            // 获取当前登录用户信息
            WxLoginUser wxLoginUser = getWxLoginUser();
            String openId = wxLoginUser.getCOpenid();

            Long momentId = momentService.publishMoment(dto, openId);
            return R.ok(momentId, dto.getIsDraft() != null && dto.getIsDraft() == 1 ? "保存草稿成功" : "发布成功，等待审核");
        } catch (Exception e) {
            log.error("发布动态失败", e);
            return R.fail("发布动态失败：" + e.getMessage());
        }
    }

    /**
     * 编辑动态
     *
     * @param dto 编辑动态请求对象
     * @return R<Long> 动态ID
     */
    @PostMapping("/edit")
    @ApiOperation("编辑动态")
    public R<Long> editMoment(@Valid @RequestBody EditMomentDTO dto) {
        try {
            log.info("编辑动态的请求参数：{}", JSON.toJSONString(dto));
            // 获取当前登录用户信息
            WxLoginUser wxLoginUser = getWxLoginUser();
            String openId = wxLoginUser.getCOpenid();

            Long momentId = momentService.editMoment(dto, openId);
            return R.ok(momentId, dto.getIsDraft() != null && dto.getIsDraft() == 1 ? "保存草稿成功" : "提交成功，等待审核");
        } catch (Exception e) {
            log.error("编辑动态失败", e);
            return R.fail("编辑动态失败：" + e.getMessage());
        }
    }

    /**
     * 查询我的动态列表（已发布的动态：审核中+审核通过+审核拒绝）
     *
     * @param pageNum  页码
     * @param pageSize 每页数量
     * @return R 我的动态列表
     */
    @GetMapping("/my")
    @ApiOperation("查询我的动态列表")
    public R<Page<MyMomentVO>> getMyMoments(@ApiParam("页码") @RequestParam(defaultValue = "1") Integer pageNum, @ApiParam("每页数量") @RequestParam(defaultValue = "10") Integer pageSize) {
        try {
            // 获取当前登录用户信息
            WxLoginUser wxLoginUser = getWxLoginUser();
            String openId = wxLoginUser.getCOpenid();
            log.info("查询我的动态列表，openId：{}，页码：{}，每页数量：{}", openId, pageNum, pageSize);

            Page<MyMomentVO> page = momentService.getMyMoments(openId, pageNum, pageSize);
            return R.ok(page);
        } catch (Exception e) {
            log.error("查询我的动态列表失败", e);
            return R.fail("查询我的动态列表失败：" + e.getMessage());
        }
    }

    /**
     * 删除我的动态
     *
     * @param momentId 动态ID
     * @return R<Boolean> 是否删除成功
     */
    @DeleteMapping("/{momentId}")
    @ApiOperation("删除我的动态")
    public R<Boolean> deleteMyMoment(@ApiParam("动态ID") @PathVariable Long momentId) {
        try {
            WxLoginUser wxLoginUser = getWxLoginUser();
            String openId = wxLoginUser.getCOpenid();
            log.info("删除我的动态，openId：{}，动态ID：{}", openId, momentId);

            Boolean result = momentService.deleteMyMoment(momentId, openId);
            return R.ok(result, "动态删除成功");
        } catch (ServiceException e) {
            e.printStackTrace();
            log.warn("删除我的动态业务校验失败，动态ID：{}，原因：{}", momentId, e.getMessage());
            return R.fail(e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail("删除动态失败");
        }
    }


    /**
     * 根据技师ID查询技师的动态列表（已发布的动态：审核中+审核通过）
     *
     * @param technicianId 技师ID
     * @return R 技师的动态列表
     */
    @GetMapping("/queryMomentByTechnicianId")
    @ApiOperation("根据技师ID查询动态列表")
    public R<?> getMyMoments(@RequestParam String technicianId) {
        try {
            List<MomentListVO> list = momentService.getMomentsByTechnicianId(technicianId);
            return R.ok(list);
        } catch (Exception e) {
            log.error("查询我的动态列表失败", e);
            return R.fail("查询我的动态列表失败：" + e.getMessage());
        }
    }

    /**
     * 查询草稿箱列表
     *
     * @param pageNum  页码
     * @param pageSize 每页数量
     * @return R<Page<MomentListVO>>
     */
    @GetMapping("/drafts")
    @ApiOperation("查询草稿箱列表")
    public R<Page<MomentListVO>> getDraftMoments(@ApiParam("页码") @RequestParam(defaultValue = "1") Integer pageNum, @ApiParam("每页数量") @RequestParam(defaultValue = "10") Integer pageSize) {
        try {
            // 获取当前登录用户信息
            WxLoginUser wxLoginUser = getWxLoginUser();
            String openId = wxLoginUser.getCOpenid();
            log.info("查询草稿箱列表，openId：{}", openId);

            Page<MomentListVO> draftMoments = momentService.getDraftMoments(openId, pageNum, pageSize);
            return R.ok(draftMoments);
        } catch (Exception e) {
            log.error("查询草稿箱列表失败", e);
            return R.fail("查询草稿箱列表失败：" + e.getMessage());
        }
    }

    /**
     * 查询动态管理列表（PC管理后台）
     *
     * @param queryDTO 查询参数
     * @return R 分页结果
     */
    @GetMapping("/manage/list")
    @ApiOperation("查询动态管理列表")
    public R<Page<MomentManageVO>> getMomentManageList(@Valid MomentManageQueryDTO queryDTO) {
        try {
            log.info("查询动态管理列表，参数：{}", queryDTO);
            Page<MomentManageVO> page = momentService.getMomentManageList(queryDTO);
            return R.ok(page);
        } catch (Exception e) {
            log.error("查询动态管理列表失败", e);
            return R.fail("查询动态管理列表失败：" + e.getMessage());
        }
    }

    /**
     * 查询动态管理审核状态统计（PC管理后台）
     *
     * @return R<MomentAuditStatusCountVO> 审核状态统计
     */
    @GetMapping("/manage/audit-status/count")
    @ApiOperation("查询动态管理审核状态统计")
    public R<MomentAuditStatusCountVO> getManageAuditStatusCount() {
        try {
            MomentAuditStatusCountVO count = momentService.getManageAuditStatusCount();
            return R.ok(count);
        } catch (Exception e) {
            log.error("查询动态管理审核状态统计失败", e);
            return R.fail("查询动态管理审核状态统计失败：" + e.getMessage());
        }
    }

    /**
     * 审核动态（通过/拒绝）
     *
     * @param dto 动态审核请求对象
     * @return R 是否成功
     */
    @PostMapping("/manage/audit")
    @ApiOperation("审核动态")
    public R<Boolean> auditMoment(@Valid @RequestBody MomentAuditDTO dto) {
        try {
            log.info("请求的审核动态参数：{}", JSON.toJSONString(dto));
            Boolean result = momentService.auditMoment(dto);
            String message = dto.getAuditStatus() == 2 ? "审核通过" : "审核拒绝";
            return R.ok(result, message);
        } catch (Exception e) {
            log.error("审核动态失败", e);
            return R.fail("审核动态失败：" + e.getMessage());
        }
    }

    /**
     * 更新动态推荐状态
     *
     * @param momentId 动态ID
     * @param dto      推荐状态请求对象
     * @return R<Boolean> 是否成功
     */
    @PutMapping("/manage/{momentId}/recommend")
    @ApiOperation("更新动态推荐状态")
    public R<Boolean> updateRecommendStatus(@ApiParam("动态ID") @PathVariable Long momentId, @Valid @RequestBody MomentRecommendDTO dto) {
        try {
            log.info("更新动态推荐状态，动态ID：{}，是否推荐：{}", momentId, dto.getIsRecommend());
            Boolean result = momentService.updateRecommendStatus(momentId, dto.getIsRecommend());
            String message = dto.getIsRecommend() == 1 ? "推荐成功" : "取消推荐成功";
            return R.ok(result, message);
        } catch (Exception e) {
            log.error("更新动态推荐状态失败", e);
            return R.fail("更新动态推荐状态失败：" + e.getMessage());
        }
    }

    /**
     * 更新动态上架状态
     *
     * @param momentId 动态ID
     * @param dto      上架状态请求对象
     * @return R<Boolean> 是否成功
     */
    @PutMapping("/manage/{momentId}/list-status")
    @ApiOperation("更新动态上架状态")
    public R<Boolean> updateListStatus(@ApiParam("动态ID") @PathVariable Long momentId, @Valid @RequestBody MomentListStatusDTO dto) {
        try {
            log.info("更新动态上架状态，动态ID：{}，是否上架：{}", momentId, dto.getIsList());
            Boolean result = momentService.updateListStatus(momentId, dto.getIsList());
            String message = dto.getIsList() == 1 ? "上架成功" : "下架成功";
            return R.ok(result, message);
        } catch (Exception e) {
            log.error("更新动态上架状态失败", e);
            return R.fail("更新动态上架状态失败：" + e.getMessage());
        }
    }

    /**
     * 根据动态ID查询动态详情
     *
     * @param momentId 动态ID
     * @return R<MomentSimpleDetailVO>
     */
    @GetMapping("/simple/detail/{momentId}")
    @ApiOperation("根据动态ID查询动态简要详情")
    public R<MomentSimpleDetailVO> getMomentSimpleDetail(@ApiParam("动态ID") @PathVariable Long momentId) {
        try {
            log.info("查询动态简要详情，动态ID：{}", momentId);
            MomentSimpleDetailVO detail = momentService.getMomentSimpleDetail(momentId);
            return R.ok(detail);
        } catch (Exception e) {
            log.error("查询动态简要详情失败", e);
            return R.fail("查询动态简要详情失败：" + e.getMessage());
        }
    }

}
