package jnpf.elnEntity.formula;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.BooleanNode;
import com.fasterxml.jackson.databind.node.DecimalNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.TextNode;
import lombok.Data;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public final class ElnFormulaForms {

    @Data
    public static class Query {
        private int currentPage = 1;
        private int pageSize = 20;
        private String keyword;
        private String bizEnabled;
    }

    @Data
    public static class ReferenceQuery {
        private int currentPage = 1;
        private int pageSize = 20;
        private String keyword;
    }

    @Data
    public static class Create extends VersionRule {
        private String gongshiMingcheng;
        private String yewuYongtu;
        private String beizhu;
    }

    @Data
    public static class CreateDraft {
        private String gongshiMingcheng;
        private String yewuYongtu;
        private String beizhu;
        private List<Parameter> parameters = new ArrayList<>();
    }

    @Data
    public static class UpdateDefinition {
        private String gongshiMingcheng;
        private String yewuYongtu;
        private String beizhu;
    }

    @Data
    public static class CreateVersion {
        private String sourceVersionId;
    }

    @Data
    public static class UpdateVersion extends VersionRule {
    }

    @Data
    public static class Validate extends VersionRule {
    }

    @Data
    public static class Preview extends VersionRule {
        @JsonDeserialize(contentUsing = InputJsonNodeDeserializer.class)
        private Map<String, JsonNode> inputs = new LinkedHashMap<>();
    }

    public static final class InputJsonNodeDeserializer extends JsonDeserializer<JsonNode> {

        @Override
        public JsonNode deserialize(JsonParser parser, DeserializationContext context)
                throws IOException {
            return read(parser);
        }

        @Override
        public JsonNode getNullValue(DeserializationContext context) {
            return NullNode.instance;
        }

        private static JsonNode read(JsonParser parser) throws IOException {
            JsonToken token = parser.currentToken();
            if (token == JsonToken.VALUE_NUMBER_INT || token == JsonToken.VALUE_NUMBER_FLOAT) {
                String source = parser.getText();
                try {
                    return new InputDecimalNode(new BigDecimal(source), source);
                } catch (NumberFormatException ex) {
                    return JsonNodeFactory.instance.numberNode(parser.getDoubleValue());
                }
            }
            if (token == JsonToken.VALUE_STRING) {
                return TextNode.valueOf(parser.getText());
            }
            if (token == JsonToken.VALUE_TRUE || token == JsonToken.VALUE_FALSE) {
                return BooleanNode.valueOf(token == JsonToken.VALUE_TRUE);
            }
            if (token == JsonToken.VALUE_NULL) {
                return NullNode.instance;
            }
            if (token == JsonToken.START_ARRAY) {
                ArrayNode result = JsonNodeFactory.instance.arrayNode();
                while (parser.nextToken() != JsonToken.END_ARRAY) {
                    result.add(read(parser));
                }
                return result;
            }
            if (token == JsonToken.START_OBJECT) {
                ObjectNode result = JsonNodeFactory.instance.objectNode();
                while (parser.nextToken() != JsonToken.END_OBJECT) {
                    String fieldName = parser.currentName();
                    parser.nextToken();
                    result.set(fieldName, read(parser));
                }
                return result;
            }
            throw JsonMappingException.from(parser, "不支持的公式试算输入 JSON token");
        }
    }

    public static final class InputDecimalNode extends DecimalNode {
        private final String source;

        private InputDecimalNode(BigDecimal value, String source) {
            super(value);
            this.source = source;
        }

        public String getSource() {
            return source;
        }
    }

    @Data
    public static class VersionRule {
        private String biaodashi;
        private String jieguoLeixing;
        private Integer xiuyueXiaoshuWei;
        private String xiuyueMoshi;
        private List<Parameter> parameters = new ArrayList<>();
    }

    @Data
    public static class Parameter {
        private String id;
        private String canshuBianma;
        private String canshuMingcheng;
        private String shujuLeixing;
        private String danwei;
        private Integer shifouBitian;
        private Integer paixu;
    }

    @Data
    public static class Reason {
        private String reason;
    }

    @Data
    public static class SwitchCurrent extends Reason {
        private String versionId;
    }

    @Data
    public static class TemplateBinding {
        private String formulaVersionId;
        private Map<String, String> parameterBindings = new LinkedHashMap<>();
        private String resultBindingId;
        private String operationCode;
        private List<ControlSnapshot> jieguoSuoKuaizhao = new ArrayList<>();
    }

    @Data
    public static class FormulaMutation {
        private String operationCode;
        private Integer expectedVersion;
    }

    @Data
    public static class ControlSnapshot {
        private String bindingId;
        private String controlTag;
        private String controlRole;
        private String lock;
    }

    @Data
    public static class ActivateFormulaBinding extends FormulaMutation {
        private List<ControlSnapshot> controls = new ArrayList<>();
    }

    @Data
    public static class CancelFormulaBinding extends FormulaMutation {
        private String reason;
    }

    @Data
    public static class UpgradeMappingConfirm extends FormulaMutation {
        private TemplateBinding target;
        private List<ControlSnapshot> controls = new ArrayList<>();
    }

    @Data
    public static class RemoveMappingConfirm extends FormulaMutation {
        private List<ControlSnapshot> controls = new ArrayList<>();
    }

    @Data
    public static class FormulaVersionCopyConfirm {
        private String upgradeOperationCode;
        private Map<String, Integer> expectedVersions = new LinkedHashMap<>();
        private List<ControlSnapshot> controls = new ArrayList<>();
    }

    private ElnFormulaForms() {
    }
}