package com.yanzuoguang.util;


import com.yanzuoguang.util.base.ObjectHelper;
import com.yanzuoguang.util.helper.JsonHelper;
import com.yanzuoguang.util.helper.StringFormatHandle;
import com.yanzuoguang.util.helper.StringHelper;
import com.yanzuoguang.util.printer.ConvertPlan;
import com.yanzuoguang.util.printer.format.FormatCenter;
import com.yanzuoguang.util.printer.vo.PrinterPagerData;
import com.yanzuoguang.util.printer.vo.PrinterPagerItemData;
import com.yanzuoguang.util.vo.MapRow;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 构造函数
 *
 * @author 颜佐光
 */
public class PrinterHelper {

    /**
     * 将来源模板与数据转换为目标模板和数据
     *
     * @param pager 来源模板
     * @param datas 来源数据
     * @return
     */
    public static ConvertPlan convertArray(String pager, double left, double top, Object... datas) {
        return convertList(pager, left, top, Arrays.asList(datas));
    }

    /**
     * 将来源模板与数据转换为目标模板和数据
     *
     * @param pager 来源模板
     * @param datas 来源数据
     * @return
     */
    public static ConvertPlan convertList(String pager, double left, double top, List datas) {
        ConvertPlan from = new ConvertPlan();
        from.setPager(pager);
        from.setDatas(datas);
        return convert(from, left, top);
    }

    /**
     * 将来源模板转换为目标模板
     *
     * @param from 来源计划
     * @param left 左边距离
     * @param top  右边距离
     * @return
     */
    public static ConvertPlan<MapRow> convert(ConvertPlan from, double left, double top) {
        // 设置生成结果
        ConvertPlan<MapRow> to = new ConvertPlan();
        // 判断是否为空
        if (StringHelper.isEmpty(from.getPager()) || from.getDatas() == null || from.getDatas().size() < 1) {
            return to;
        }
        // 解析模板格式
        PrinterPagerData pager;
        try {
            pager = JsonHelper.deserialize(from.getPager(), PrinterPagerData.class);
        } catch (Exception ex) {
            throw new RuntimeException("不能识别模板", ex);
        }
        // 设置偏移量
        pager.setMarginTop(pager.getMarginTop() + top);
        pager.setMarginLeft(pager.getMarginLeft() + left);

        // 初始化目标数据
        int length = from.getDatas().size();
        for (int i = 0; i < length; i++) {
            to.getDatas().add(new MapRow());
        }
        // 遍历模板，对每个模板格式化字符串进行处理
        for (PrinterPagerItemData item : pager.getItems()) {
            // 判断是否需要格式化
            if (StringHelper.isEmpty(item.getFormat()) && !StringHelper.isEmpty(item.getName())) {
                item.setFormat("{0}");
            }
            // 生成目标格式化字符串
            String format = StringHelper.getFormat(item.getFormat(), item.getName(), new StringFormatHandle() {
                @Override
                public void addPos(StringBuilder sb, String group, String fieldFull, String field, String command) {
                    // 对现有的字段进行加密
                    sb.append("{");
                    String fieldTo = field;
                    if (!StringHelper.isEmpty(command)) {
                        fieldTo = StringHelper.md5(fieldFull);
                    }
                    sb.append(fieldTo);
                    sb.append("}");

                    // 写入加密后的数目
                    for (int i = 0; i < length; i++) {
                        Object rowFrom = from.getDatas().get(i);
                        String fromValue = ObjectHelper.getString(rowFrom, field);
                        String toValue = fromValue;
                        if (!StringHelper.isEmpty(command)) {
                            toValue = FormatCenter.getFormatValue(command, fromValue);
                        }
                        MapRow rowTo = to.getDatas().get(i);
                        rowTo.put(fieldTo, toValue);
                    }
                }
            });
            item.setFormat(format);
        }
        // 设置生成模板
        to.setPager(JsonHelper.serialize(pager));
        return to;
    }

    /**
     * 将数据格式化为新得数据，用于转换单行数据
     *
     * @param resultTo     结果数据
     * @param resultFrom   结果来源
     * @param format       格式化
     * @param defaultField 默认字段
     * @return
     */
    public static String getFormatTo(Map<String, Object> resultTo, Object resultFrom,
                                     String format, String defaultField) {
        return StringHelper.getFormat(format, defaultField, new StringFormatHandle() {
            @Override
            public void addPos(StringBuilder sb, String group, String fieldFull, String field, String command) {
                sb.append("{");
                Object fieldValue = ObjectHelper.get(resultFrom, field);
                String fieldTo = field;
                if (!StringHelper.isEmpty(command)) {
                    fieldTo = StringHelper.md5(fieldFull);
                }
                sb.append(fieldTo);
                resultTo.put(fieldTo, fieldValue);
                sb.append("}");
            }
        });
    }

    /**
     * 获取结果字符串，用于转换单行数据，调用本方法前请先调用getFormatTo函数
     *
     * @param resultFrom 来源字符
     * @param format     格式化字符串
     * @return
     */
    public static String getResult(Object resultFrom, String format) {
        return StringHelper.getFormat(format, StringHelper.EMPTY, new StringFormatHandle() {
            @Override
            public void addPos(StringBuilder sb, String group, String fieldFull, String field, String command) {
                Object fieldValue = ObjectHelper.get(resultFrom, field);
                sb.append(fieldValue);
            }
        });
    }
}