// Generated by delombok at Mon Jan 02 16:27:27 UTC 2023
package io.cui.tools.reflect;

import java.lang.reflect.Field;
import java.util.Optional;
import io.cui.tools.lang.SecuritySupport;
import io.cui.tools.logging.CuiLogger;
import io.cui.tools.string.MoreStrings;
import lombok.NonNull;
// owolff: The warning is "Reflection should not be used to
// increase accessibility of classes, methods, or fields "
// What is actually the use-case of this type, therefore there
// is nothing we can do
/**
 * Wrapper around a {@link Field} that handles implicitly the accessible flag for access.
 *
 * @author Oliver Wolff
 */
@SuppressWarnings("java:S3011")
public class FieldWrapper {
    private static final CuiLogger log = new CuiLogger(FieldWrapper.class);
    @NonNull
    private final Field field;
    private final boolean initialAccessible;

    /**
     * @param field must not be null
     */
    public FieldWrapper(Field field) {
        this.field = field;
        initialAccessible = field.isAccessible();
    }

    /**
     * Reads from the field determined by {@link #getField()}. It implicitly sets and resets the
     * {@link Field#isAccessible()} flag.
     *
     * @param object to be read from
     * @return an {@link Optional} on the given field value if applicable. May return
     *         {@link Optional#empty()} for cases where:
     *         <ul>
     *         <li>Field value is {@code null}</li>
     *         <li>Given Object is {@code null}</li>
     *         <li>Given Object is improper type</li>
     *         <li>an {@link IllegalAccessException} occurred while accessing</li>
     *         </ul>
     */
    public Optional<Object> readValue(Object object) {
        log.trace("Reading from field \'{}\' with accessibleFlag=\'{}\' ", field, initialAccessible);
        if (null == object) {
            log.trace("No Object given, returning Optional#empty()");
            return Optional.empty();
        }
        synchronized (field) {
            if (!initialAccessible) {
                log.trace("Explicitly setting accessible flag");
                SecuritySupport.setAccessible(field, true);
            }
            try {
                return Optional.ofNullable(field.get(object));
            } catch (IllegalArgumentException | IllegalAccessException e) {
                log.warn(e, "Reading from field \'{}\' with accessible=\'{}\' and parameter =\'{}\' could not complete", field, initialAccessible, object);
                return Optional.empty();
            } finally {
                if (!initialAccessible) {
                    log.trace("Resetting accessible flag");
                    SecuritySupport.setAccessible(field, false);
                }
            }
        }
    }

    /**
     * Reads the value from the field in the given object. It implicitly sets and resets the
     * {@link Field#isAccessible()} flag.
     *
     * @param fieldName to be read
     * @param object to be read from
     *
     * @return the field value. {@link Optional#empty()} if the field cannot be read.
     */
    public static final Optional<Object> readValue(final String fieldName, final Object object) {
        final Optional<FieldWrapper> fieldProvider = from(object.getClass(), fieldName);
        log.trace("FieldWrapper: {}", fieldProvider);
        if (fieldProvider.isPresent()) {
            FieldWrapper fieldWrapper = fieldProvider.get();
            return fieldWrapper.readValue(object);
        }
        return Optional.empty();
    }

    /**
     * Writes to the field determined by {@link #getField()}. It implicitly sets and resets the
     * {@link Field#isAccessible()} flag.
     *
     * @param object to be written to, must not be null
     * @param value to be written, may be null
     *
     * @throws NullPointerException in case object is {@code null}
     * @throws IllegalArgumentException in case the value is not applicable to the field
     * @throws IllegalStateException wrapping an {@link IllegalAccessException}
     */
    public void writeValue(@NonNull Object object, Object value) {
        if (object == null) {
            throw new java.lang.NullPointerException("object is marked non-null but is null");
        }
        log.trace("Writing to field \'{}\' with accessibleFlag=\'{}\' ", field, initialAccessible);
        synchronized (field) {
            if (!initialAccessible) {
                log.trace("Explicitly setting accessible flag");
                SecuritySupport.setAccessible(field, true);
            }
            try {
                field.set(object, value);
            } catch (IllegalAccessException e) {
                String message = MoreStrings.lenientFormat("Writing to field \'{}\' with accessible=\'{}\' and parameter =\'{}\' could not complete", field, initialAccessible, object);
                throw new IllegalStateException(message, e);
            } finally {
                if (!initialAccessible) {
                    log.trace("Resetting accessible flag");
                    SecuritySupport.setAccessible(field, false);
                }
            }
        }
    }

    /**
     * Factory Method for creating an {@link FieldWrapper} instance
     *
     * @param type must not be null
     * @param fieldName must not be null
     * @return a {@link FieldWrapper} if the {@link Field} can be determined,
     *         {@link Optional#empty()} otherwise
     */
    public static final Optional<FieldWrapper> from(final Class<?> type, final String fieldName) {
        Optional<Field> loaded = MoreReflection.accessField(type, fieldName);
        if (loaded.isPresent()) {
            return Optional.of(new FieldWrapper(loaded.get()));
        } else {
            return Optional.empty();
        }
    }

    @NonNull
    @java.lang.SuppressWarnings("all")
    @lombok.Generated
    public Field getField() {
        return this.field;
    }
}