/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.basepom.mojo.propertyhelper.definitions;

import static com.google.common.base.Preconditions.checkState;

import org.basepom.mojo.propertyhelper.Field;
import org.basepom.mojo.propertyhelper.FieldContext;
import org.basepom.mojo.propertyhelper.IgnoreWarnFail;
import org.basepom.mojo.propertyhelper.IgnoreWarnFailCreate;
import org.basepom.mojo.propertyhelper.ValueCache;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.StringJoiner;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Splitter;

/**
 * Common properties for a field.
 */
public abstract class FieldDefinition<T> {

    protected FieldDefinition() {
    }

    @VisibleForTesting
    protected FieldDefinition(String id) {
        this.id = id;
    }

    /**
     * Name of the build property to define. Field injected by Maven.
     */
    String id = null;

    /**
     * <code>True</code> skips the parsing of this definition. Field injected by Maven.
     */
    boolean skip = false;

    /**
     * Whether to export this number directly. Field injected by Maven.
     */
    boolean export = false;

    /**
     * Name of the property from the properties file. Field injected by Maven.
     */
    String propertyNameInFile = null;

    /**
     * Name of the properties file to persist the count. Field injected by Maven.
     */
    File propertyFile = null;

    /**
     * What to do when the property is missing from the file.
     */
    private IgnoreWarnFailCreate onMissingFile = IgnoreWarnFailCreate.FAIL;

    public void setOnMissingFile(String onMissingFile) {
        this.onMissingFile = IgnoreWarnFailCreate.forString(onMissingFile);
    }

    /**
     * What to do when the property is missing from the file.
     */
    private IgnoreWarnFailCreate onMissingFileProperty = IgnoreWarnFailCreate.FAIL;

    public void setOnMissingFileProperty(String onMissingFileProperty) {
        this.onMissingFileProperty = IgnoreWarnFailCreate.forString(onMissingFileProperty);
    }

    /**
     * What to do when a referenced property can not be resolved.
     */
    private IgnoreWarnFail onMissingProperty = IgnoreWarnFail.FAIL;

    public void setOnMissingProperty(String onMissingProperty) {
        this.onMissingProperty = IgnoreWarnFail.forString(onMissingProperty);
    }

    /**
     * The initial value for this field. Field injected by Maven.
     */
    String initialValue = null;

    /**
     * Regular expression matcher. Field injected by Maven.
     */
    private Pattern regexp = null;

    public void setRegexp(String regexp) {
        checkState(regexp.startsWith("^"), "regular expression must start with '^'!");
        checkState(regexp.endsWith("$"), "regular expression must end with '$'!");

        this.regexp = Pattern.compile(regexp);
    }

    /**
     * Format for this element. Field injected by Maven.
     */
    String format = null;

    /**
     * Comma separated list of String transformers.
     */
    private List<String> transformers = List.of();

    public void setTransformers(String transformers) {
        this.transformers = Splitter.on(",")
            .omitEmptyStrings()
            .trimResults()
            .splitToList(transformers);
    }

    public abstract <U extends Field<?, ?>> U createField(FieldContext context, ValueCache valueCache) throws IOException;

    public String getId() {
        return id;
    }

    public boolean isSkip() {
        return skip;
    }

    public List<String> getTransformers() {
        return transformers;
    }

    public Optional<String> getInitialValue() {
        return Optional.ofNullable(initialValue);
    }

    public boolean isExport() {
        return export;
    }

    public String getPropertyNameInFile() {
        return Objects.requireNonNullElse(propertyNameInFile, id);
    }

    public Optional<File> getPropertyFile() {
        return Optional.ofNullable(propertyFile);
    }

    public IgnoreWarnFailCreate getOnMissingFile() {
        return onMissingFile;
    }

    public IgnoreWarnFailCreate getOnMissingFileProperty() {
        return onMissingFileProperty;
    }

    public IgnoreWarnFail getOnMissingProperty() {
        return onMissingProperty;
    }

    public Function<String, String> getRegexp() {
        return regexp == null ? Function.identity() : v -> {
            Matcher matcher = regexp.matcher(v);
            return matcher.matches() ? matcher.group(1) : "";
        };
    }

    public Function<T, String> getPreFormat() {
        return v -> v == null ? "" : String.valueOf(v);
    }

    public Function<String, String> getPostFormat() {
        return format == null ? String::valueOf : v -> String.format(format, v);
    }

    public void check() {
        checkState(id != null, "the id element must not be empty!");

        if (propertyNameInFile != null) {
            checkState(propertyFile != null, "can not define <propertyNameInFile> without defining <propertyFile>!");
        }
    }

    @Override
    public String toString() {
        return new StringJoiner(", ", FieldDefinition.class.getSimpleName() + "[", "]")
            .add("id='" + id + "'")
            .add("skip=" + skip)
            .add("export=" + export)
            .add("propertyNameInFile='" + propertyNameInFile + "'")
            .add("propertyFile=" + propertyFile)
            .add("onMissingFile=" + onMissingFile)
            .add("onMissingFileProperty=" + onMissingFileProperty)
            .add("onMissingProperty=" + onMissingProperty)
            .add("initialValue='" + initialValue + "'")
            .add("format='" + format + "'")
            .add("transformers=" + transformers)
            .toString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        FieldDefinition<?> that = (FieldDefinition<?>) o;
        return skip == that.skip && export == that.export && Objects.equals(id, that.id) && Objects.equals(propertyNameInFile,
            that.propertyNameInFile) && Objects.equals(propertyFile, that.propertyFile) && onMissingFile == that.onMissingFile
            && onMissingFileProperty == that.onMissingFileProperty && onMissingProperty == that.onMissingProperty && Objects.equals(initialValue,
            that.initialValue) && Objects.equals(format, that.format) && Objects.equals(transformers, that.transformers);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, skip, export, propertyNameInFile, propertyFile, onMissingFile, onMissingFileProperty, onMissingProperty, initialValue, format,
            transformers);
    }
}