/*
 * 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.fields;

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.ValueProvider;
import org.basepom.mojo.propertyhelper.definitions.NumberDefinition;

import java.util.List;
import java.util.Optional;
import java.util.StringJoiner;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;

public final class NumberField extends Field<String, NumberDefinition> {

    private final ValueProvider valueProvider;

    // internal state
    private List<NumberElement> numberElements;
    private List<NumberElement> numberIndex;

    @VisibleForTesting
    public static NumberField forTesting(NumberDefinition numberDefinition, ValueProvider valueProvider) {
        return new NumberField(numberDefinition, valueProvider, FieldContext.forTesting());
    }

    public NumberField(final NumberDefinition fieldDefinition, final ValueProvider valueProvider,
        FieldContext fieldContext) {
        super(fieldDefinition, fieldContext);

        this.valueProvider = valueProvider;
    }

    @Override
    public String getFieldName() {
        // This is not the property name (because many definitions can map onto one prop)
        // but the actual id.
        return fieldDefinition.getId();
    }

    @Override
    public String getValue() {
        parse();

        return formatResult(value().map(v -> Long.toString(v))
            .orElse(valueProvider.getValue().orElse("")));
    }

    private void parse() {
        final Optional<String> value = valueProvider.getValue();

        ImmutableList.Builder<NumberElement> numberELementBuilder = ImmutableList.builder();
        ImmutableList.Builder<NumberElement> numberIndexBuilder = ImmutableList.builder();

        if (value.isPresent()) {
            String numberValue = value.get();
            if (!numberValue.isBlank()) {
                StringBuilder sb = new StringBuilder();
                int charIndex = 0;
                boolean number = Character.isDigit(numberValue.charAt(charIndex));

                while (charIndex < numberValue.length()) {
                    char currentChar = numberValue.charAt(charIndex);
                    if (number != Character.isDigit(currentChar)) {
                        var numberElement = new NumberElement(number, sb.toString());

                        numberELementBuilder.add(numberElement);
                        if (number) {
                            numberIndexBuilder.add(numberElement);
                        }

                        number = !number;
                        sb.setLength(0);
                    }
                    sb.append(currentChar);
                    charIndex++;
                }
                if (sb.length() > 0) {
                    var numberElement = new NumberElement(number, sb.toString());

                    numberELementBuilder.add(numberElement);
                    if (number) {
                        numberIndexBuilder.add(numberElement);
                    }
                }
            }
        }

        this.numberElements = numberELementBuilder.build();
        this.numberIndex = numberIndexBuilder.build();
    }

    private String print() {
        return Joiner.on("").join(numberElements.stream().map(NumberElement::getFieldValue).iterator());
    }

    private Optional<Long> value() {
        return fieldDefinition.getFieldNumber()
            .map(fieldNumber -> numberIndex.get(fieldNumber))
            .flatMap(NumberElement::getLongValue);
    }

    private void set(long value) {
        Optional<NumberElement> numberElement = fieldDefinition.getFieldNumber()
            .map(fieldNumber -> numberIndex.get(fieldNumber));

        if (numberElement.isPresent()) {
            numberElement.get().setLongValue(value);
            valueProvider.setValue(print());
        } else {
            valueProvider.setValue(Long.toString(value));
        }
    }

    public void increment() {
        parse();

        fieldDefinition.getFieldNumber().ifPresent(fieldNumber -> checkState(numberIndex.size() > fieldNumber,
            "Only %s fields in %s, field %s requested.", numberElements.size(), print(), fieldNumber));

        value().ifPresent(value -> {
            set(value + fieldDefinition.getIncrement());
        });
    }

    public Optional<Long> getNumberValue() {
        parse();

        fieldDefinition.getFieldNumber().ifPresent(fieldNumber -> checkState(numberIndex.size() > fieldNumber,
            "Only %s fields in %s, field %s requested.", numberElements.size(), print(), fieldNumber));

        return value();
    }

    @Override
    public String toString() {
        return new StringJoiner(", ", NumberField.class.getSimpleName() + "[", "]")
            .add("valueProvider=" + valueProvider)
            .add("numberElements=" + numberElements)
            .add("numberIndex=" + numberIndex)
            .add("fieldDefinition=" + fieldDefinition)
            .toString();
    }

    private static final class NumberElement {

        private final boolean number;
        private String value;

        private NumberElement(boolean number, String value) {
            this.number = number;
            this.value = value;
        }

        String getFieldValue() {
            return value;
        }

        void setLongValue(long value) {
            this.value = Long.toString(value);
        }

        Optional<Long> getLongValue() {
            return number ? Optional.of(Long.parseLong(value)) : Optional.empty();
        }

        @Override
        public String toString() {
            return new StringJoiner(", ", NumberElement.class.getSimpleName() + "[", "]")
                .add("number=" + number)
                .add("value='" + value + "'")
                .toString();
        }
    }
}