package com.haha.admin.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.haha.admin.annotation.RequirePermission;
import com.haha.common.annotation.Log;
import com.haha.common.enums.ActivityTypeEnum;
import com.haha.common.enums.OperationType;
import com.haha.common.vo.PageResult;
import com.haha.common.vo.Result;
import com.haha.entity.InviteRecord;
import com.haha.entity.dto.InviteRecordQueryDTO;
import com.haha.entity.dto.UnifiedActivityCreateDTO;
import com.haha.entity.dto.UnifiedActivityQueryDTO;
import com.haha.entity.dto.UnifiedActivityUpdateDTO;
import com.haha.entity.vo.UnifiedActivityVO;
import com.haha.service.UnifiedActivityService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

/**
 * 统一活动管理控制器
 * 提供统一的 RESTful API 接口，支持所有类型活动的 CRUD 操作
 * 内部调用 UnifiedActivityService 调度器，根据活动类型自动分发到对应的具体服务实现
 *
 * <p>支持的活动类型：
 * <ul>
 *   <li>1 - 首单立减（营销活动）</li>
 *   <li>2 - 优惠折扣（营销活动）</li>
 *   <li>3 - 商品满减（营销活动）</li>
 *   <li>4 - 邀请有礼（邀请活动）</li>
 * </ul>
 *
 * <p>API 基础路径：/marketing/activities/unified
 */
@Slf4j
@RestController
@RequestMapping("/marketing/activities/unified")
@RequiredArgsConstructor
public class UnifiedActivityController {

    private final UnifiedActivityService unifiedActivityService;

    // ==================== 查询接口 ====================

    /**
     * 统一分页查询所有类型活动（包括邀请有礼）
     * 支持按 activityType 筛选特定类型的活动，或查询全部活动
     *
     * @param queryDTO 查询条件（包含分页参数和筛选条件）
     * @return 分页结果，统一转换为 UnifiedActivityVO 格式
     */
    @RequirePermission("marketing:activity:list")
    @GetMapping("/page")
    public Result<PageResult<UnifiedActivityVO>> getPage(UnifiedActivityQueryDTO queryDTO) {
        queryDTO.validate();
        log.info("[统一活动] 分页查询 - type: {}, page: {}", queryDTO.getActivityType(), queryDTO.getPage());
        IPage<UnifiedActivityVO> page = unifiedActivityService.getPage(queryDTO);
        return Result.success("查询成功", PageResult.of(page));
    }

    /**
     * 统一详情查询
     * 根据 type 参数从对应的服务获取详情并转换为统一格式
     *
     * @param id   活动ID
     * @param type 活动类型（1-4）
     * @return 活动详情（统一VO格式）
     */
    @RequirePermission("marketing:activity:read")
    @GetMapping("/{id}")
    public Result<UnifiedActivityVO> getDetail(@PathVariable Long id,
                                               @RequestParam Integer type) {
        log.info("[统一活动] 详情 - id: {}, type: {}", id, type);
        UnifiedActivityVO detail = unifiedActivityService.getDetail(id, type);
        return Result.success(detail);
    }

    // ==================== 创建和更新接口 ====================

    /**
     * 统一创建活动（自动根据 type 分发）
     * 根据 activityType 自动路由到 MarketingActivityService 或 InviteActivityService
     *
     * @param dto 统一创建请求DTO（包含 activityType 字段用于类型判断）
     * @return 创建成功后的活动ID
     */
    @RequirePermission("marketing:activity:create")
    @Log(module = "统一活动", operation = OperationType.INSERT, summary = "创建活动")
    @PostMapping
    public Result<Long> create(@RequestBody UnifiedActivityCreateDTO dto) {
        // 根据类型进行分组校验
        if (dto.getActivityType() == ActivityTypeEnum.INVITE_REWARD.getCode()) {
            // 邀请活动的特殊校验
            if (dto.getInviterCouponTemplateId() == null) {
                return Result.error("邀请人优惠券模板不能为空");
            }
            if (dto.getDailyLimit() == null) {
                return Result.error("每日邀请上限不能为空");
            }
        }

        log.info("[统一活动] 创建 - type: {}, name: {}", dto.getActivityType(), dto.getActivityName());
        Long id = unifiedActivityService.create(dto);
        return Result.success("创建成功", id);
    }

    /**
     * 统一更新活动
     * 根据 type 参数自动分发到对应的服务
     *
     * @param id  活动ID
     * @param type 活动类型（1-4）
     * @param dto 统一更新请求DTO
     * @return 操作结果
     */
    @RequirePermission("marketing:activity:edit")
    @Log(module = "统一活动", operation = OperationType.UPDATE, summary = "编辑活动")
    @PutMapping("/{id}")
    public Result<Void> update(@PathVariable Long id,
                               @RequestParam Integer type,
                               @RequestBody UnifiedActivityUpdateDTO dto) {
        dto.setId(id);
        log.info("[统一活动] 更新 - id: {}, type: {}", id, type);
        unifiedActivityService.update(dto);
        return Result.success("更新成功");
    }

    // ==================== 状态管理接口 ====================

    /**
     * 发布活动
     * 将活动从草稿状态变更为已发布/进行中状态
     *
     * @param id   活动ID
     * @param type 活动类型（1-4）
     * @return 操作结果
     */
    @RequirePermission("marketing:activity:publish")
    @Log(module = "统一活动", operation = OperationType.UPDATE, summary = "发布活动")
    @PutMapping("/{id}/publish")
    public Result<Void> publish(@PathVariable Long id,
                                @RequestParam Integer type) {
        log.info("[统一活动] 发布 - id: {}, type: {}", id, type);
        unifiedActivityService.publish(id, type);
        return Result.success("发布成功");
    }

    /**
     * 暂停活动
     * 将活动从进行中状态变更为已暂停状态
     *
     * @param id   活动ID
     * @param type 活动类型（1-4）
     * @return 操作结果
     */
    @RequirePermission("marketing:activity:edit")
    @Log(module = "统一活动", operation = OperationType.UPDATE, summary = "暂停活动")
    @PutMapping("/{id}/pause")
    public Result<Void> pause(@PathVariable Long id,
                              @RequestParam Integer type) {
        log.info("[统一活动] 暂停 - id: {}, type: {}", id, type);
        unifiedActivityService.pause(id, type);
        return Result.success("暂停成功");
    }

    /**
     * 恢复活动
     * 将活动从暂停状态恢复为进行中状态
     *
     * @param id   活动ID
     * @param type 活动类型（1-4）
     * @return 操作结果
     */
    @RequirePermission("marketing:activity:edit")
    @Log(module = "统一活动", operation = OperationType.UPDATE, summary = "恢复活动")
    @PutMapping("/{id}/resume")
    public Result<Void> resume(@PathVariable Long id,
                               @RequestParam Integer type) {
        log.info("[统一活动] 恢复 - id: {}, type: {}", id, type);
        unifiedActivityService.resume(id, type);
        return Result.success("恢复成功");
    }

    /**
     * 删除活动（逻辑删除）
     *
     * @param id   活动ID
     * @param type 活动类型（1-4）
     * @return 操作结果
     */
    @RequirePermission("marketing:activity:delete")
    @Log(module = "统一活动", operation = OperationType.DELETE, summary = "删除活动")
    @DeleteMapping("/{id}")
    public Result<Void> delete(@PathVariable Long id,
                               @RequestParam Integer type) {
        log.warn("[统一活动] 删除 - id: {}, type: {}", id, type);
        unifiedActivityService.delete(id, type);
        return Result.success("删除成功");
    }

    // ==================== 邀请活动特有接口 (type=4) ====================

    /**
     * 查询邀请记录（仅 type=4 时调用）
     * 获取指定邀请活动的邀请记录详情
     *
     * @param activityId 邀请活动ID
     * @param queryDTO   查询条件（包含分页参数和筛选条件）
     * @return 邀请记录分页结果
     */
    @RequirePermission("marketing:activity:read")
    @GetMapping("/{activityId}/invite-records")
    public Result<PageResult<InviteRecord>> getInviteRecords(
            @PathVariable Long activityId,
            InviteRecordQueryDTO queryDTO) {
        log.info("[统一活动] 查询邀请记录 - activityId: {}, page: {}",
                activityId, queryDTO.getPage());
        IPage<InviteRecord> page = unifiedActivityService.getInviteRecords(activityId, queryDTO);
        return Result.success(PageResult.of(page));
    }

    /**
     * 获取邀请统计数据（仅 type=4 时调用）
     * 包含总邀请数、有效邀请数、今日邀请数、奖励发放统计等
     *
     * @param activityId 邀请活动ID
     * @return 统计数据Map
     */
    @RequirePermission("marketing:activity:read")
    @GetMapping("/{activityId}/invite-statistics")
    public Result<Map<String, Object>> getInviteStatistics(@PathVariable Long activityId) {
        log.info("[统一活动] 查询邀请统计 - activityId: {}", activityId);
        Map<String, Object> stats = unifiedActivityService.getInviteStatistics(activityId);
        return Result.success(stats);
    }
}
