package eu.eudat.file.transformer.entities.descriptiontemplate.fielddata;

import com.fasterxml.jackson.annotation.JsonValue;
import eu.eudat.file.transformer.enums.DatabaseEnum;
import eu.eudat.file.transformer.enums.EnumUtils;
import eu.eudat.file.transformer.enums.FieldDataComboBoxType;
import eu.eudat.file.transformer.enums.FieldType;
import eu.eudat.file.transformer.model.descriptiontemplatedefinition.fielddata.AutoCompleteData;
import eu.eudat.file.transformer.model.descriptiontemplatedefinition.fielddata.AutoCompleteSingleData;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class AutoCompleteDataEntity extends ComboBoxDataEntity<AutoCompleteDataEntity, AutoCompleteData> {

    public static class AuthAutoCompleteData {
        private String url;
        private String method;
        private String body;
        private String path;
        private String type;

        public String getUrl() {
            return url;
        }

        public void setUrl(String url) {
            this.url = url;
        }

        public String getMethod() {
            return method;
        }

        public void setMethod(String method) {
            this.method = method;
        }

        public String getBody() {
            return body;
        }

        public void setBody(String body) {
            this.body = body;
        }

        public String getPath() {
            return path;
        }

        public void setPath(String path) {
            this.path = path;
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }
    }
    public static class AutoCompleteSingleData {
        private AutocompleteType autocompleteType;
        private String url;
        private ComboBoxDataEntity.Option autoCompleteOptions;
        private String optionsRoot;
        private Boolean hasAuth;
        private AuthAutoCompleteData auth;
        private String method;

        public AutocompleteType getAutocompleteType() {
            return autocompleteType;
        }

        public void setAutocompleteType(AutocompleteType autocompleteType) {
            this.autocompleteType = autocompleteType;
        }

        public String getOptionsRoot() {
            return optionsRoot;
        }
        public void setOptionsRoot(String optionsRoot) {
            this.optionsRoot = optionsRoot;
        }

        public String getUrl() {
            return url;
        }
        public void setUrl(String url) {
            this.url = url;
        }

        public Boolean getHasAuth() {
            return hasAuth;
        }

        public void setHasAuth(Boolean hasAuth) {
            this.hasAuth = hasAuth;
        }

        public AuthAutoCompleteData getAuth() {
            return auth;
        }

        public void setAuth(AuthAutoCompleteData auth) {
            this.auth = auth;
        }

        public ComboBoxDataEntity.Option getAutoCompleteOptions() {
            return autoCompleteOptions;
        }
        public void setAutoCompleteOptions(ComboBoxDataEntity.Option autoCompleteOptions) {
            this.autoCompleteOptions = autoCompleteOptions;
        }

        public String getMethod() {
            return method;
        }

        public void setMethod(String method) {
            this.method = method;
        }
    }

    private Boolean multiAutoComplete;
    private List<AutoCompleteSingleData> autoCompleteSingleDataList;

    public Boolean getMultiAutoComplete() { return multiAutoComplete; }
    public void setMultiAutoComplete(Boolean multiAutoComplete) { this.multiAutoComplete = multiAutoComplete; }

    public List<AutoCompleteSingleData> getAutoCompleteSingleDataList() {
        return autoCompleteSingleDataList;
    }

    public void setAutoCompleteSingleDataList(List<AutoCompleteSingleData> autoCompleteSingleDataList) {
        this.autoCompleteSingleDataList = autoCompleteSingleDataList;
    }

    @Override
    public FieldDataComboBoxType getFieldSubType() {
        return FieldDataComboBoxType.Autocomplete;
    }

    @Override
    public FieldType getFieldType() {
        return FieldType.AUTO_COMPLETE;
    }

    /*@Override
    public Element toXml(Document doc) {
        Element root = super.toXml(doc);
        if (this.multiAutoComplete != null)
            root.setAttribute("multiAutoComplete", this.multiAutoComplete.toString());
        for (AutoCompleteSingleData singleData: this.autoCompleteSingleDataList) {
            Element parent = doc.createElement("autocompleteSingle");
            parent.setAttribute("url", singleData.url);
            parent.setAttribute("optionsRoot", singleData.optionsRoot);
            parent.setAttribute("autoCompleteType", Integer.toString(singleData.autocompleteType.getValue()));
            parent.setAttribute("hasAuth", Boolean.toString(singleData.hasAuth));
            parent.setAttribute("method", singleData.method);
            Element element = doc.createElement("option");
            element.setAttribute("label", singleData.autoCompleteOptions.getLabel());
            element.setAttribute("value", singleData.autoCompleteOptions.getValue());
            element.setAttribute("source", singleData.autoCompleteOptions.getSource());
            parent.appendChild(element);
            if (singleData.hasAuth) {
                Element authElement = doc.createElement("auth");
                authElement.setAttribute("url", singleData.auth.url);
                authElement.setAttribute("method", singleData.auth.method);
                authElement.setAttribute("body", singleData.auth.body);
                authElement.setAttribute("path", singleData.auth.path);
                authElement.setAttribute("type", singleData.auth.type);
                parent.appendChild(authElement);
            }
            root.appendChild(parent);
        }
        return root;
    }*/

    /*@Override
    public AutoCompleteDataEntity fromXml(Element item) {
        super.fromXml(item);
        this.autoCompleteSingleDataList = new ArrayList<>();
        NodeList items = item.getElementsByTagName("autocompleteSingle");
        if (items != null && items.getLength() > 0) {
            for (int i = 0; i < items.getLength(); i++) {
                this.autoCompleteSingleDataList.add(new AutoCompleteSingleData());
                Element single = (Element) items.item(i);
                this.mapFromXml(single, this.autoCompleteSingleDataList.get(i));
            }
        } else {
            this.autoCompleteSingleDataList.add(new AutoCompleteSingleData());
            this.mapFromXml(item, this.autoCompleteSingleDataList.get(0));
        }
        this.multiAutoComplete = Boolean.parseBoolean(item.getAttribute("multiAutoComplete"));
        return this;
    }*/

/*
    private void mapFromXml(Element item, AutoCompleteSingleData singleData) {
        singleData.url = item.getAttribute("url");
        singleData.optionsRoot = item.getAttribute("optionsRoot");
        this.multiAutoComplete = Boolean.parseBoolean(item.getAttribute("multiAutoComplete"));
        if (item.getAttribute("autoCompleteType") == null || item.getAttribute("autoCompleteType").equals("") ) {
            singleData.autocompleteType = AutocompleteType.UNCACHED;
        } else {
            singleData.autocompleteType = AutocompleteType.of(Integer.parseInt(item.getAttribute("autoCompleteType")));
        }
        singleData.hasAuth = Boolean.parseBoolean(item.getAttribute("hasAuth"));
        singleData.method = item.hasAttribute("method") ? item.getAttribute("method") : "GET";
        Element optionElement = (Element) item.getElementsByTagName("option").item(0);
        if (optionElement != null) {
            singleData.autoCompleteOptions = new Option();
            singleData.autoCompleteOptions.setLabel(optionElement.getAttribute("label"));
            singleData.autoCompleteOptions.setValue(optionElement.getAttribute("value"));
            singleData.autoCompleteOptions.setSource(optionElement.getAttribute("source"));
            singleData.autoCompleteOptions.setUri(optionElement.getAttribute("uri"));
        }
        if (singleData.hasAuth) {
            Element authElement = (Element) item.getElementsByTagName("auth").item(0);
            if (authElement != null) {
                singleData.auth = new AuthAutoCompleteData();
                singleData.auth.setUrl(authElement.getAttribute("url"));
                singleData.auth.setMethod(authElement.getAttribute("method"));
                singleData.auth.setBody(authElement.getAttribute("body"));
                singleData.auth.setPath(authElement.getAttribute("path"));
                singleData.auth.setType(authElement.getAttribute("type"));
            }
        }
    }
*/
    public enum AutocompleteType implements DatabaseEnum<Integer> {
        UNCACHED(0),
        CACHED(1);

        private final int value;

        AutocompleteType(int value) {
            this.value = value;
        }

        @JsonValue
        public Integer getValue() {
            return value;
        }

        private static final Map<Integer, AutocompleteType> map = EnumUtils.getEnumValueMap(AutocompleteType.class);

        public static AutocompleteType of(int i) {
            return map.get(i);
        }
    }

    @Override
    public AutoCompleteDataEntity fromDefinition(AutoCompleteData item) {
        super.fromDefinition(item);
        this.autoCompleteSingleDataList = new ArrayList<>();
        if (item.getAutoCompleteSingleDataList() != null && !item.getAutoCompleteSingleDataList().isEmpty()) {
            for (eu.eudat.file.transformer.model.descriptiontemplatedefinition.fielddata.AutoCompleteSingleData singleData : item.getAutoCompleteSingleDataList()) {
                AutoCompleteSingleData single = new AutoCompleteSingleData();
                this.mapFromDefinition(singleData, single);
                this.autoCompleteSingleDataList.add(single);
            }
        } else {
            this.autoCompleteSingleDataList.add(new AutoCompleteSingleData());
            this.mapFromDefinition(item.getAutoCompleteSingleDataList().get(0), this.autoCompleteSingleDataList.get(0));
        }
        this.multiAutoComplete = item.getMultiAutoComplete();
        return this;
    }

    private void mapFromDefinition(eu.eudat.file.transformer.model.descriptiontemplatedefinition.fielddata.AutoCompleteSingleData item, AutoCompleteSingleData singleData) {
        singleData.url = item.getUrl();
        singleData.optionsRoot = item.getOptionsRoot();
        this.multiAutoComplete = false;
        if (item.getAutocompleteType() == null ) {
            singleData.autocompleteType = AutocompleteType.UNCACHED;
        } else {
            singleData.autocompleteType = item.getAutocompleteType();
        }
        singleData.hasAuth = item.getHasAuth() != null ? item.getHasAuth() : false;
        singleData.method = item.getMethod() != null && !item.getMethod().isEmpty() ? item.getMethod() : "GET";
        if (item.getAutoCompleteOptions() != null) {
            singleData.autoCompleteOptions = new Option();
            singleData.autoCompleteOptions.setLabel(item.getAutoCompleteOptions().getLabel());
            singleData.autoCompleteOptions.setValue(item.getAutoCompleteOptions().getValue());
            singleData.autoCompleteOptions.setSource(item.getAutoCompleteOptions().getSource());
            singleData.autoCompleteOptions.setUri(item.getAutoCompleteOptions().getUri());
        }
        if (singleData.hasAuth) {
            if (item.getAuth() != null) {
                singleData.auth = new AuthAutoCompleteData();
                singleData.auth.setUrl(item.getAuth().getUrl());
                singleData.auth.setMethod(item.getAuth().getMethod());
                singleData.auth.setBody(item.getAuth().getBody());
                singleData.auth.setPath(item.getAuth().getPath());
                singleData.auth.setType(item.getAuth().getType());
            }
        }
    }
}