package report

import (
	"context"
	"strconv"
	"strings"

	reportSvc "dataengine/common/report"
	"dataengine/common/report/model"

	"gitea.redpowerfuture.com/red-future/common/beans"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/sirupsen/logrus"
)

// ============================================================
// 批量操作（供 PPGo_Job 调度）
// ============================================================

type extractAllReq struct {
	g.Meta `path:"/extractAll" method:"post" tags:"报表引擎" summary:"全量抽取" dc:"遍历所有启用业务+报表，抽取前一天数据"`
}

type extractAllRes struct {
	Success bool   `json:"success"`
	Message string `json:"message"`
}

func (c *report) ExtractAll(ctx context.Context, req *extractAllReq) (*extractAllRes, error) {
	ctx = ctxWithUser(ctx)
	logrus.Info("[HTTP] 触发全量抽取")
	reportSvc.ExecDailyExtract(ctx)
	return &extractAllRes{Success: true, Message: "全量抽取已触发"}, nil
}

type report struct{}

var ReportController = new(report)

func svc() *reportSvc.ReportService {
	return reportSvc.GetService()
}

func ctxWithUser(ctx context.Context) context.Context {
	return context.WithValue(ctx, "user", &beans.User{UserName: "admin", TenantId: 1})
}

// ============================================================
// 业务 CRUD
// ============================================================

type listBusinessesReq struct {
	g.Meta `path:"/businesses" method:"get" tags:"报表引擎" summary:"业务列表"`
	model.PageReq
}

type listBusinessesRes struct {
	List []model.BusinessConfig `json:"list"`
	model.PageRes
}

func (c *report) ListBusinesses(ctx context.Context, req *listBusinessesReq) (*listBusinessesRes, error) {
	ctx = ctxWithUser(ctx)
	list, total, err := svc().ListBusinesses(ctx, req.PageNum, req.PageSize)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取业务列表失败: %v", err)
		return nil, err
	}
	totalPages := (total + req.PageSize - 1) / req.PageSize
	return &listBusinessesRes{List: list, PageRes: model.PageRes{Total: total, Page: req.PageNum, PageSize: req.PageSize, TotalPages: totalPages}}, nil
}

type getBusinessReq struct {
	g.Meta `path:"/business" method:"get" tags:"报表引擎" summary:"获取业务"`
	ID     int64 `json:"id" v:"required"`
}

type getBusinessRes struct {
	Data *model.BusinessConfig `json:"data"`
}

func (c *report) GetBusiness(ctx context.Context, req *getBusinessReq) (*getBusinessRes, error) {
	ctx = ctxWithUser(ctx)
	data, err := svc().GetBusiness(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取业务失败 id=%d: %v", req.ID, err)
		return nil, err
	}
	return &getBusinessRes{Data: data}, nil
}

type saveBusinessReq struct {
	g.Meta `path:"/business/save" method:"post" tags:"报表引擎" summary:"保存业务"`
	model.SaveBusinessReq
}

type saveBusinessRes struct {
	*model.SaveResult
}

func (c *report) SaveBusiness(ctx context.Context, req *saveBusinessReq) (*saveBusinessRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().SaveBusiness(ctx, &req.SaveBusinessReq)
	if err != nil {
		logrus.Errorf("[报表引擎] 保存业务失败: %v", err)
		return nil, err
	}
	return &saveBusinessRes{SaveResult: result}, nil
}

type deleteBusinessReq struct {
	g.Meta `path:"/business" method:"delete" tags:"报表引擎" summary:"删除业务"`
	ID     int64 `json:"id" v:"required"`
}

type deleteBusinessRes struct {
	*model.DeleteResult
}

func (c *report) DeleteBusiness(ctx context.Context, req *deleteBusinessReq) (*deleteBusinessRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().DeleteBusiness(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 删除业务失败 id=%d: %v", req.ID, err)
		return nil, err
	}
	return &deleteBusinessRes{DeleteResult: result}, nil
}

// ============================================================
// 报表 CRUD
// ============================================================

type listReportsReq struct {
	g.Meta       `path:"/reports" method:"get" tags:"报表引擎" summary:"报表列表"`
	BusinessCode string `json:"businessCode" v:"required"`
	ReportName   string `json:"reportName" dc:"报表名称（模糊搜索）"`
	model.PageReq
}

type listReportsRes struct {
	List []model.ReportConfig `json:"list"`
	model.PageRes
}

func (c *report) ListReports(ctx context.Context, req *listReportsReq) (*listReportsRes, error) {
	ctx = ctxWithUser(ctx)
	list, total, err := svc().ListReports(ctx, req.BusinessCode, req.ReportName, req.PageNum, req.PageSize)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取报表列表失败 %s: %v", req.BusinessCode, err)
		return nil, err
	}

	// 填充抽取配置ID（逗号分隔，不限 status）
	for i := range list {
		configs, err := svc().GetExtractConfigsAll(ctx, list[i].BusinessCode, list[i].ReportCode)
		if err == nil {
			ids := make([]string, 0, len(configs))
			for _, ec := range configs {
				ids = append(ids, strconv.FormatInt(ec.Id, 10))
			}
			list[i].ExtractConfigIDs = strings.Join(ids, ",")
		}
	}

	totalPages := (total + req.PageSize - 1) / req.PageSize
	return &listReportsRes{List: list, PageRes: model.PageRes{Total: total, Page: req.PageNum, PageSize: req.PageSize, TotalPages: totalPages}}, nil
}

type getReportReq struct {
	g.Meta `path:"/report" method:"get" tags:"报表引擎" summary:"获取报表"`
	ID     int64 `json:"id" v:"required"`
}

type getReportRes struct {
	Data *model.ReportConfig `json:"data"`
}

func (c *report) GetReport(ctx context.Context, req *getReportReq) (*getReportRes, error) {
	ctx = ctxWithUser(ctx)
	data, err := svc().GetReport(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取报表失败 id=%d: %v", req.ID, err)
		return nil, err
	}

	// 填充抽取配置ID（逗号分隔，不限 status）
	configs, err := svc().GetExtractConfigsAll(ctx, data.BusinessCode, data.ReportCode)
	if err == nil {
		ids := make([]string, 0, len(configs))
		for _, ec := range configs {
			ids = append(ids, strconv.FormatInt(ec.Id, 10))
		}
		data.ExtractConfigIDs = strings.Join(ids, ",")
	}

	return &getReportRes{Data: data}, nil
}

type saveReportReq struct {
	g.Meta `path:"/report/save" method:"post" tags:"报表引擎" summary:"保存报表"`
	model.SaveReportReq
}

type saveReportRes struct {
	*model.SaveResult
}

func (c *report) SaveReport(ctx context.Context, req *saveReportReq) (*saveReportRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().SaveReport(ctx, &req.SaveReportReq)
	if err != nil {
		logrus.Errorf("[报表引擎] 保存报表失败: %v", err)
		return nil, err
	}
	return &saveReportRes{SaveResult: result}, nil
}

type saveReportWithFieldsReq struct {
	g.Meta `path:"/report/saveWithFields" method:"post" tags:"报表引擎" summary:"保存报表及字段配置（全量替换）"`
	model.SaveReportWithFieldsReq
}

type saveReportWithFieldsRes struct {
	*model.SaveResult
}

func (c *report) SaveReportWithFields(ctx context.Context, req *saveReportWithFieldsReq) (*saveReportWithFieldsRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().SaveReportWithFields(ctx, &req.SaveReportWithFieldsReq)
	if err != nil {
		logrus.Errorf("[报表引擎] 保存报表及字段失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
		return nil, err
	}
	logrus.Infof("[报表引擎] 保存报表及字段成功 %s/%s id=%d", req.BusinessCode, req.ReportCode, result.ID)
	return &saveReportWithFieldsRes{SaveResult: result}, nil
}

type deleteReportReq struct {
	g.Meta `path:"/report" method:"delete" tags:"报表引擎" summary:"删除报表"`
	ID     int64 `json:"id" v:"required"`
}

type deleteReportRes struct {
	*model.DeleteResult
}

func (c *report) DeleteReport(ctx context.Context, req *deleteReportReq) (*deleteReportRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().DeleteReport(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 删除报表失败 id=%d: %v", req.ID, err)
		return nil, err
	}
	return &deleteReportRes{DeleteResult: result}, nil
}

// ============================================================
// 字段 CRUD
// ============================================================

type getReportFieldsReq struct {
	g.Meta       `path:"/fields" method:"get" tags:"报表引擎" summary:"报表字段列表（按角色分组）"`
	BusinessCode string `json:"businessCode" v:"required"`
	ReportCode   string `json:"reportCode" v:"required"`
	model.PageReq
}

func (c *report) GetReportFields(ctx context.Context, req *getReportFieldsReq) (*model.GetReportFieldsResp, error) {
	ctx = ctxWithUser(ctx)
	resp, err := svc().GetReportFields(ctx, req.BusinessCode, req.ReportCode)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取报表字段失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
		return nil, err
	}
	return resp, nil
}

type getFieldReq struct {
	g.Meta `path:"/field" method:"get" tags:"报表引擎" summary:"获取字段"`
	ID     int64 `json:"id" v:"required"`
}

type getFieldRes struct {
	Data *model.FieldConfig `json:"data"`
}

func (c *report) GetField(ctx context.Context, req *getFieldReq) (*getFieldRes, error) {
	ctx = ctxWithUser(ctx)
	data, err := svc().GetField(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取字段失败 id=%d: %v", req.ID, err)
		return nil, err
	}
	return &getFieldRes{Data: data}, nil
}

type saveFieldReq struct {
	g.Meta `path:"/field/save" method:"post" tags:"报表引擎" summary:"保存字段"`
	model.SaveFieldReq
}

type saveFieldRes struct {
	*model.SaveResult
}

func (c *report) SaveField(ctx context.Context, req *saveFieldReq) (*saveFieldRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().SaveField(ctx, &req.SaveFieldReq)
	if err != nil {
		logrus.Errorf("[报表引擎] 保存字段失败: %v", err)
		return nil, err
	}
	return &saveFieldRes{SaveResult: result}, nil
}

type deleteFieldReq struct {
	g.Meta `path:"/field" method:"delete" tags:"报表引擎" summary:"删除字段"`
	ID     int64 `json:"id" v:"required"`
}

type deleteFieldRes struct {
	*model.DeleteResult
}

func (c *report) DeleteField(ctx context.Context, req *deleteFieldReq) (*deleteFieldRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().DeleteField(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 删除字段失败 id=%d: %v", req.ID, err)
		return nil, err
	}
	return &deleteFieldRes{DeleteResult: result}, nil
}

// ============================================================
// 抽取配置 CRUD
// ============================================================

type getExtractConfigsReq struct {
	g.Meta       `path:"/extractConfigs" method:"get" tags:"报表引擎" summary:"抽取配置列表"`
	BusinessCode string `json:"businessCode" v:"required"`
	ReportCode   string `json:"reportCode" v:"required"`
	model.PageReq
}

type getExtractConfigsRes struct {
	List []model.ExtractConfig `json:"list"`
	model.PageRes
}

func (c *report) GetExtractConfigs(ctx context.Context, req *getExtractConfigsReq) (*getExtractConfigsRes, error) {
	ctx = ctxWithUser(ctx)
	list, total, err := svc().ListExtractConfigs(ctx, req.BusinessCode, req.ReportCode, req.PageNum, req.PageSize)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取抽取配置列表失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
		return nil, err
	}
	totalPages := (total + req.PageSize - 1) / req.PageSize
	return &getExtractConfigsRes{List: list, PageRes: model.PageRes{Total: total, Page: req.PageNum, PageSize: req.PageSize, TotalPages: totalPages}}, nil
}

type getExtractConfigReq struct {
	g.Meta `path:"/extractConfig" method:"get" tags:"报表引擎" summary:"获取抽取配置"`
	ID     int64 `json:"id" v:"required"`
}

type getExtractConfigRes struct {
	Data *model.ExtractConfig `json:"data"`
}

func (c *report) GetExtractConfig(ctx context.Context, req *getExtractConfigReq) (*getExtractConfigRes, error) {
	ctx = ctxWithUser(ctx)
	data, err := svc().GetExtractConfig(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 获取抽取配置失败 id=%d: %v", req.ID, err)
		return nil, err
	}
	return &getExtractConfigRes{Data: data}, nil
}

type saveExtractConfigReq struct {
	g.Meta `path:"/extractConfig/save" method:"post" tags:"报表引擎" summary:"保存抽取配置"`
	model.SaveExtractConfigReq
}

type saveExtractConfigRes struct {
	*model.SaveResult
}

func (c *report) SaveExtractConfig(ctx context.Context, req *saveExtractConfigReq) (*saveExtractConfigRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().SaveExtractConfig(ctx, &req.SaveExtractConfigReq)
	if err != nil {
		logrus.Errorf("[报表引擎] 保存抽取配置失败: %v", err)
		return nil, err
	}
	return &saveExtractConfigRes{SaveResult: result}, nil
}

type deleteExtractConfigReq struct {
	g.Meta `path:"/extractConfig" method:"delete" tags:"报表引擎" summary:"删除抽取配置"`
	ID     int64 `json:"id" v:"required"`
}

type deleteExtractConfigRes struct {
	*model.DeleteResult
}

func (c *report) DeleteExtractConfig(ctx context.Context, req *deleteExtractConfigReq) (*deleteExtractConfigRes, error) {
	ctx = ctxWithUser(ctx)
	result, err := svc().DeleteExtractConfig(ctx, req.ID)
	if err != nil {
		logrus.Errorf("[报表引擎] 删除抽取配置失败 id=%d: %v", req.ID, err)
		return nil, err
	}
	return &deleteExtractConfigRes{DeleteResult: result}, nil
}

// ============================================================
// 数据操作
// ============================================================

type extractDataReq struct {
	g.Meta `path:"/extract" method:"post" tags:"报表引擎" summary:"执行按天数据抽取"`
	model.ExtractDailyDataReq
}

func (c *report) ExtractData(ctx context.Context, req *extractDataReq) (*model.ExtractDailyDataResp, error) {
	ctx = ctxWithUser(ctx)
	resp, err := svc().ExtractDailyData(ctx, req.BusinessCode, req.ReportCode, req.StatDate, req.Executor)
	if err != nil {
		logrus.Errorf("[报表引擎] 按天抽取失败 %s/%s %s: %v", req.BusinessCode, req.ReportCode, req.StatDate, err)
		return nil, err
	}
	return resp, nil
}

type backfillReq struct {
	g.Meta `path:"/backfill" method:"post" tags:"报表引擎" summary:"批量回填数据"`
	model.BackfillReq
}

func (c *report) Backfill(ctx context.Context, req *backfillReq) (*model.BackfillResp, error) {
	ctx = ctxWithUser(ctx)
	resp, err := svc().Backfill(ctx, &req.BackfillReq)
	if err != nil {
		logrus.Errorf("[报表引擎] 批量回填失败 %s/%s %s~%s: %v", req.BusinessCode, req.ReportCode, req.StartDate, req.EndDate, err)
		return nil, err
	}
	return resp, nil
}

type autoCreateTableReq struct {
	g.Meta `path:"/autoCreateTable" method:"post" tags:"报表引擎" summary:"自动创建统计宽表"`
	model.AutoCreateStatTableReq
}

func (c *report) AutoCreateTable(ctx context.Context, req *autoCreateTableReq) (*model.AutoCreateStatTableResp, error) {
	ctx = ctxWithUser(ctx)
	resp, err := svc().AutoCreateStatTable(ctx, req.BusinessCode, req.ReportCode)
	if err != nil {
		logrus.Errorf("[报表引擎] 自动建表失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
		return nil, err
	}
	return resp, nil
}

type queryReportReq struct {
	g.Meta `path:"/query" method:"post" tags:"报表引擎" summary:"用户选择查询"`
	model.UserSelectQueryReq
}

func (c *report) QueryReport(ctx context.Context, req *queryReportReq) (*model.UserSelectQueryResp, error) {
	ctx = ctxWithUser(ctx)
	resp, err := svc().QueryReportByUserSelect(ctx, &req.UserSelectQueryReq)
	if err != nil {
		logrus.Errorf("[报表引擎] 查询报表失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
		return nil, err
	}
	return resp, nil
}

type initTablesReq struct {
	g.Meta `path:"/initTables" method:"post" tags:"报表引擎" summary:"初始化系统表"`
}

type initTablesRes struct {
	Success bool   `json:"success"`
	Message string `json:"message"`
}

func (c *report) InitTables(ctx context.Context, req *initTablesReq) (*initTablesRes, error) {
	ctx = ctxWithUser(ctx)
	if err := svc().InitSystemTables(ctx); err != nil {
		return nil, err
	}
	return &initTablesRes{Success: true, Message: "系统表初始化完成"}, nil
}