package foundation.data.meta.field;

import foundation.data.entity.Entity;
import foundation.data.meta.template.PropertyTemplate;
import foundation.json.IJSONWriter;
import foundation.util.Util;


public class FieldExtension {
	
    private String fieldName;
    private String labelChinese;
    private String labelEnglish;
    private String inputType;
    private String optionsKey;
    private String optionsPattern;
    private String formatter;
    private String formatPattern;
    private String translator;
    private Align align;
    private boolean required;
    private String validateRegex;
    private String defaultValue;
    private Integer minVal;
    private Integer maxVal;
    private String prefix;
    private String suffix;
    private boolean exportable;
    private boolean importable;

    
    public FieldExtension() {
    	align = Align.left;
    }

	public static void toEntity(String dataName, Field field, Entity entity, PropertyTemplate template) {
		int indexNo = field.getIndexNo();
		String fieldName = field.getName();
		
		String labelChinese = field.getRemark();
		
		if (Util.isEmpty(labelChinese)) {
			labelChinese = fieldName;
		}
		
		if (labelChinese.length() > 24) {
			labelChinese = labelChinese.substring(0, 24);
		}
 		
		entity.set("id", dataName + "_" + Util.format(indexNo, 3));
		entity.set("dataName", dataName);
		entity.set("field_name", fieldName);
		entity.set("label_chinese", labelChinese);
		entity.set("label_english", fieldName);
		
		if (field.isNumber()) {
			entity.set("align", Align.right.name());
		}
		else if (field.isDate()) {
			entity.set("input_type", "input");
			entity.set("formatter", "formatter_date");
			entity.set("align", Align.center.name());
		}
		else {
			entity.set("align", Align.center.name());
		}
		
		if (template != null) {
			Entity data = template.getData();
			String[] names = data.getFieldsMeta().getFieldNames();
			int max = names.length;
			
			for (int i = 0; i < max; i++) {
				String name = names[i];
				
				if (PropertyTemplate.ExcludeNames.contains(name)) {
					continue;
				}
				
				Object value = data.getValue(i);
				
				if (Util.isEmpty(value)) {
					continue;
				}
				
				entity.set(name, value);
			}
		}
	}
	
    public void load(Entity entity) {
    	fieldName = entity.getString("field_name");
        labelChinese = entity.getString("label_chinese");
        labelEnglish = entity.getString("label_english");
        inputType = entity.getString("input_type");
        optionsKey = entity.getString("options_key");
        optionsPattern = entity.getString("options_pattern");
        formatter = entity.getString("formatter");
        translator = entity.getString("translator");
        
        formatPattern = entity.getString("format_pattern");
        align = Align.parse(entity.getString("align"));
        required = entity.getBoolean("is_required", false);
        validateRegex = entity.getString("validate_regex");
        defaultValue = entity.getString("default_value");
        minVal = entity.getInteger("min_val", null);
        maxVal = entity.getInteger("max_val", null);
        prefix = entity.getString("prefix");
        suffix = entity.getString("suffix");        
        exportable = entity.getBoolean("is_exportable", true);
        importable = entity.getBoolean("is_importable", true);        
    }

	public Entity toEntity(Entity entity) {
    	entity.set("field_name", fieldName);
        entity.set("label_chinese", labelChinese);
        entity.set("label_english", labelEnglish);
        entity.set("input_type", inputType);
        entity.set("options_key", optionsKey);
        entity.set("options_pattern", optionsPattern);
        entity.set("formatter", formatter);
        entity.set("translator", translator);
        
        entity.set("format_pattern", formatPattern);
        entity.set("align", align.name());
        entity.set("is_required", required);
        entity.set("validate_regex", validateRegex);
        entity.set("default_value", defaultValue);
        entity.set("min_val", minVal);
        entity.set("max_val", maxVal);
        entity.getString("prefix", prefix);
        entity.getString("suffix", suffix);        
        entity.getBoolean("is_exportable", exportable);
        entity.getBoolean("is_importable", importable);
        
        return entity;
	}
	
    public String getName() {
        return this.fieldName;
    }

	public String getLabelChinese() {
		return labelChinese;
	}

	public String getLabelEnglish() {
		return labelEnglish;
	}

	public String getInputType() {
		return inputType;
	}

	public String getOptionsKey() {
		return optionsKey;
	}

	public String getOptionsPattern() {
		return optionsPattern;
	}

	public String getFormatter() {
		return formatter;
	}

	public String getFormatPattern() {
		return formatPattern;
	}

	public String getTranslator() {
		return translator;
	}

	public boolean hasTranslator() {
		return !Util.isEmpty(translator);
	}

	public Align getAlign() {
		return align;
	}

	public boolean isRequired() {
		return required;
	}

	public String getValidateRegex() {
		return validateRegex;
	}

	public boolean hasValidateRegex() {
		return !Util.isEmpty(validateRegex);
	}

	public String getDefaultValue() {
		return defaultValue;
	}

	public boolean hasDefaultValue() {
		return !Util.isEmpty(defaultValue);
	}

	public Integer getMinVal() {
		return minVal;
	}

	public Integer getMaxVal() {
		return maxVal;
	}

	public String getPrefix() {
		return prefix;
	}

	public String getSuffix() {
		return suffix;
	}

	public boolean isExportable() {
		return exportable;
	}

	public boolean isImportable() {
		return importable;
	}

	public void setFieldName(String fieldName) {
		this.fieldName = fieldName;
	}

	public void setAlign(Align align) {
		this.align = align;
	}

	public void writeJSONBody(IJSONWriter writer) {
		writer.write("input_type", inputType);
		writer.write("options_key", optionsKey);
		writer.write("options_pattern", optionsPattern);
		writer.write("formatter", formatter);
		writer.write("format_pattern", formatPattern);
		writer.write("align", align.name());
		writer.write("is_required", required);
		writer.write("validate_regex", validateRegex);
		writer.write("default_value", defaultValue);
		writer.write("min_val", minVal);
		writer.write("max_val", maxVal);
		writer.write("prefix", prefix);
		writer.write("suffix", suffix);
	}

	public String toString() {
        StringBuilder result = new StringBuilder();
        result.append("fieldName=").append(this.fieldName).append(",");
        result.append("label=").append(this.labelChinese);
        return result.toString();
    }

    public void toString(StringBuilder result) {
        result.append("fieldName=").append(this.fieldName).append(",");
        result.append("label=").append(this.labelChinese);
    }

}