package com.vincent.rsf.server.common.domain.report;

import java.util.*;

public class ReportQueryRequest {
    private Long current = 1L;
    private Long pageSize = 12L;
    private String orderBy;
    private List<Long> ids = new ArrayList<>();
    private List<ReportColumnMeta> columns = new ArrayList<>();
    private ReportMeta reportMeta;
    private Map<String, Object> rawParams = new HashMap<>();

    public static ReportQueryRequest fromMap(Map<String, Object> map) {
        ReportQueryRequest request = new ReportQueryRequest();
        Map<String, Object> safeMap = map == null ? new HashMap<>() : new HashMap<>(map);
        request.setRawParams(safeMap);
        request.setCurrent(parseLong(safeMap.get("current"), 1L));
        request.setPageSize(parseLong(safeMap.get("pageSize"), 12L));
        request.setOrderBy(Objects.isNull(safeMap.get("orderBy")) ? null : String.valueOf(safeMap.get("orderBy")));
        request.setIds(parseIds(safeMap.get("ids")));
        request.setColumns(parseColumns(safeMap.get("columns")));
        request.setReportMeta(parseReportMeta(safeMap.get("reportMeta")));
        return request;
    }

    public Map<String, Object> toPageParamMap(boolean includeFilters) {
        Map<String, Object> queryMap = new HashMap<>(rawParams);
        queryMap.remove("ids");
        queryMap.remove("columns");
        queryMap.remove("reportMeta");

        if (!includeFilters) {
            Object resolvedOrderBy = queryMap.get("orderBy");
            queryMap.clear();
            if (!Objects.isNull(resolvedOrderBy)) {
                queryMap.put("orderBy", resolvedOrderBy);
            }
        }

        return queryMap;
    }

    public Long getCurrent() {
        return current;
    }

    public void setCurrent(Long current) {
        this.current = current;
    }

    public Long getPageSize() {
        return pageSize;
    }

    public void setPageSize(Long pageSize) {
        this.pageSize = pageSize;
    }

    public String getOrderBy() {
        return orderBy;
    }

    public void setOrderBy(String orderBy) {
        this.orderBy = orderBy;
    }

    public List<Long> getIds() {
        return ids;
    }

    public void setIds(List<Long> ids) {
        this.ids = ids;
    }

    public List<ReportColumnMeta> getColumns() {
        return columns;
    }

    public void setColumns(List<ReportColumnMeta> columns) {
        this.columns = columns;
    }

    public ReportMeta getReportMeta() {
        return reportMeta;
    }

    public void setReportMeta(ReportMeta reportMeta) {
        this.reportMeta = reportMeta;
    }

    public Map<String, Object> getRawParams() {
        return rawParams;
    }

    public void setRawParams(Map<String, Object> rawParams) {
        this.rawParams = rawParams;
    }

    private static long parseLong(Object value, long defaultValue) {
        if (Objects.isNull(value)) {
            return defaultValue;
        }
        try {
            return Long.parseLong(String.valueOf(value));
        } catch (NumberFormatException ignore) {
            return defaultValue;
        }
    }

    private static List<Long> parseIds(Object idsObj) {
        List<Long> ids = new ArrayList<>();
        if (!(idsObj instanceof Collection<?> collection)) {
            return ids;
        }
        for (Object value : collection) {
            if (Objects.isNull(value)) {
                continue;
            }
            ids.add(Long.parseLong(String.valueOf(value)));
        }
        return ids;
    }

    private static List<ReportColumnMeta> parseColumns(Object columnsObj) {
        List<ReportColumnMeta> columns = new ArrayList<>();
        if (!(columnsObj instanceof Collection<?> collection)) {
            return columns;
        }
        for (Object item : collection) {
            if (!(item instanceof Map<?, ?> columnMap)) {
                continue;
            }
            Object source = columnMap.get("source");
            if (Objects.isNull(source) || String.valueOf(source).trim().isEmpty()) {
                continue;
            }
            ReportColumnMeta columnMeta = new ReportColumnMeta();
            columnMeta.setKey(Objects.isNull(columnMap.get("key")) ? null : String.valueOf(columnMap.get("key")));
            columnMeta.setSource(String.valueOf(source));
            columnMeta.setLabel(Objects.isNull(columnMap.get("label")) ? String.valueOf(source) : String.valueOf(columnMap.get("label")));
            columnMeta.setIsExtendField(Boolean.parseBoolean(String.valueOf(columnMap.get("isExtendField"))));
            columns.add(columnMeta);
        }
        return columns;
    }

    private static ReportMeta parseReportMeta(Object reportMetaObj) {
        if (!(reportMetaObj instanceof Map<?, ?> reportMetaMap)) {
            return null;
        }
        ReportMeta reportMeta = new ReportMeta();
        reportMeta.setTitle(getMapString(reportMetaMap, "title"));
        reportMeta.setCompanyName(getMapString(reportMetaMap, "companyName"));
        reportMeta.setPrintedBy(getMapString(reportMetaMap, "printedBy"));
        reportMeta.setReportDate(getMapString(reportMetaMap, "reportDate"));
        reportMeta.setReportDateValue(getMapString(reportMetaMap, "reportDateValue"));
        return reportMeta;
    }

    private static String getMapString(Map<?, ?> map, String key) {
        Object value = map.get(key);
        return Objects.isNull(value) ? null : String.valueOf(value);
    }
}