package xyz.lychee.lagfixer.libs.adventure.text.format;

import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import xyz.lychee.lagfixer.libs.adventure.builder.AbstractBuilder;
import xyz.lychee.lagfixer.libs.adventure.key.Key;
import xyz.lychee.lagfixer.libs.adventure.text.event.ClickEvent;
import xyz.lychee.lagfixer.libs.adventure.text.event.HoverEvent;
import xyz.lychee.lagfixer.libs.adventure.text.event.HoverEventSource;
import xyz.lychee.lagfixer.libs.adventure.util.Buildable;
import xyz.lychee.lagfixer.libs.adventure.util.MonkeyBars;
import xyz.lychee.lagfixer.libs.annotations.Contract;
import xyz.lychee.lagfixer.libs.annotations.NotNull;
import xyz.lychee.lagfixer.libs.annotations.Nullable;
import xyz.lychee.lagfixer.libs.annotations.Unmodifiable;
import xyz.lychee.lagfixer.libs.annotations.ApiStatus.NonExtendable;
import xyz.lychee.lagfixer.libs.annotations.ApiStatus.ScheduledForRemoval;
import xyz.lychee.lagfixer.libs.examination.Examinable;

@NonExtendable
public interface Style extends Buildable<Style, Builder>, Examinable, StyleGetter, StyleSetter<Style> {
   Key DEFAULT_FONT = Key.key("default");

   static @NotNull Style empty() {
      return StyleImpl.EMPTY;
   }

   @NotNull
   static @NotNull Builder style() {
      return new StyleImpl.BuilderImpl();
   }

   static @NotNull Style style(final @NotNull Consumer<Builder> consumer) {
      return (Style)AbstractBuilder.configureAndBuild(style(), consumer);
   }

   static @NotNull Style style(final @Nullable TextColor color) {
      return empty().color(color);
   }

   static @NotNull Style style(final @NotNull TextDecoration decoration) {
      return style().decoration(decoration, true).build();
   }

   static @NotNull Style style(final @Nullable TextColor color, final @NotNull TextDecoration... decorations) {
      Builder builder = style();
      builder.color(color);
      builder.decorate(decorations);
      return builder.build();
   }

   static @NotNull Style style(final @Nullable TextColor color, final Set<TextDecoration> decorations) {
      Builder builder = style();
      builder.color(color);
      if (!decorations.isEmpty()) {
         Iterator var3 = decorations.iterator();

         while(var3.hasNext()) {
            TextDecoration decoration = (TextDecoration)var3.next();
            builder.decoration(decoration, true);
         }
      }

      return builder.build();
   }

   static @NotNull Style style(final @NotNull StyleBuilderApplicable... applicables) {
      int length = applicables.length;
      if (length == 0) {
         return empty();
      } else {
         Builder builder = style();

         for(int i = 0; i < length; ++i) {
            StyleBuilderApplicable applicable = applicables[i];
            if (applicable != null) {
               applicable.styleApply(builder);
            }
         }

         return builder.build();
      }
   }

   static @NotNull Style style(final @NotNull Iterable<? extends StyleBuilderApplicable> applicables) {
      Builder builder = style();
      Iterator var2 = applicables.iterator();

      while(var2.hasNext()) {
         StyleBuilderApplicable applicable = (StyleBuilderApplicable)var2.next();
         applicable.styleApply(builder);
      }

      return builder.build();
   }

   default @NotNull Style edit(final @NotNull Consumer<Builder> consumer) {
      return this.edit(consumer, Style.Merge.Strategy.ALWAYS);
   }

   default @NotNull Style edit(final @NotNull Consumer<Builder> consumer, final Merge.@NotNull Strategy strategy) {
      return style((style) -> {
         if (strategy == Style.Merge.Strategy.ALWAYS) {
            style.merge(this, strategy);
         }

         consumer.accept(style);
         if (strategy == Style.Merge.Strategy.IF_ABSENT_ON_TARGET) {
            style.merge(this, strategy);
         }

      });
   }

   @Nullable Key font();

   @NotNull Style font(final @Nullable Key font);

   @Nullable TextColor color();

   @NotNull Style color(final @Nullable TextColor color);

   @NotNull Style colorIfAbsent(final @Nullable TextColor color);

   default boolean hasDecoration(final @NotNull TextDecoration decoration) {
      return StyleGetter.super.hasDecoration(decoration);
   }

   TextDecoration.@NotNull State decoration(final @NotNull TextDecoration decoration);

   default @NotNull Style decorate(final @NotNull TextDecoration decoration) {
      return (Style)StyleSetter.super.decorate(decoration);
   }

   default @NotNull Style decoration(final @NotNull TextDecoration decoration, final boolean flag) {
      return (Style)StyleSetter.super.decoration(decoration, flag);
   }

   @NotNull Style decoration(final @NotNull TextDecoration decoration, final TextDecoration.@NotNull State state);

   @NotNull Style decorationIfAbsent(final @NotNull TextDecoration decoration, final TextDecoration.@NotNull State state);

   default @Unmodifiable @NotNull Map<TextDecoration, TextDecoration.State> decorations() {
      return StyleGetter.super.decorations();
   }

   @NotNull Style decorations(final @NotNull Map<TextDecoration, TextDecoration.State> decorations);

   @Nullable ClickEvent clickEvent();

   @NotNull Style clickEvent(final @Nullable ClickEvent event);

   @Nullable HoverEvent<?> hoverEvent();

   @NotNull Style hoverEvent(final @Nullable HoverEventSource<?> source);

   @Nullable String insertion();

   @NotNull Style insertion(final @Nullable String insertion);

   default @NotNull Style merge(final @NotNull Style that) {
      return this.merge(that, Style.Merge.all());
   }

   default @NotNull Style merge(final @NotNull Style that, final Merge.@NotNull Strategy strategy) {
      return this.merge(that, strategy, Style.Merge.all());
   }

   default @NotNull Style merge(final @NotNull Style that, @NotNull final @NotNull Merge merge) {
      return this.merge(that, Collections.singleton(merge));
   }

   default @NotNull Style merge(final @NotNull Style that, final Merge.@NotNull Strategy strategy, @NotNull final @NotNull Merge merge) {
      return this.merge(that, strategy, Collections.singleton(merge));
   }

   default @NotNull Style merge(final @NotNull Style that, final @NotNull Merge... merges) {
      return this.merge(that, Style.Merge.merges(merges));
   }

   default @NotNull Style merge(final @NotNull Style that, final Merge.@NotNull Strategy strategy, final @NotNull Merge... merges) {
      return this.merge(that, strategy, Style.Merge.merges(merges));
   }

   default @NotNull Style merge(final @NotNull Style that, final @NotNull Set<Merge> merges) {
      return this.merge(that, Style.Merge.Strategy.ALWAYS, merges);
   }

   @NotNull Style merge(final @NotNull Style that, final Merge.@NotNull Strategy strategy, final @NotNull Set<Merge> merges);

   @NotNull Style unmerge(final @NotNull Style that);

   boolean isEmpty();

   @NotNull
   @NotNull Builder toBuilder();

   public interface Builder extends AbstractBuilder<Style>, Buildable.Builder<Style>, MutableStyleSetter<Builder> {
      @Contract("_ -> this")
      @NotNull
      @NotNull Builder font(final @Nullable Key font);

      @Contract("_ -> this")
      @NotNull
      @NotNull Builder color(final @Nullable TextColor color);

      @Contract("_ -> this")
      @NotNull
      @NotNull Builder colorIfAbsent(final @Nullable TextColor color);

      @Contract("_ -> this")
      @NotNull
      default @NotNull Builder decorate(final @NotNull TextDecoration decoration) {
         return (Builder)MutableStyleSetter.super.decorate((TextDecoration)decoration);
      }

      @Contract("_ -> this")
      @NotNull
      default @NotNull Builder decorate(final @NotNull TextDecoration... decorations) {
         return (Builder)MutableStyleSetter.super.decorate(decorations);
      }

      @Contract("_, _ -> this")
      @NotNull
      default @NotNull Builder decoration(final @NotNull TextDecoration decoration, final boolean flag) {
         return (Builder)MutableStyleSetter.super.decoration(decoration, flag);
      }

      @Contract("_ -> this")
      @NotNull
      default @NotNull Builder decorations(final @NotNull Map<TextDecoration, TextDecoration.State> decorations) {
         return (Builder)MutableStyleSetter.super.decorations(decorations);
      }

      @Contract("_, _ -> this")
      @NotNull
      @NotNull Builder decoration(final @NotNull TextDecoration decoration, final TextDecoration.@NotNull State state);

      @Contract("_, _ -> this")
      @NotNull
      @NotNull Builder decorationIfAbsent(final @NotNull TextDecoration decoration, final TextDecoration.@NotNull State state);

      @Contract("_ -> this")
      @NotNull
      @NotNull Builder clickEvent(final @Nullable ClickEvent event);

      @Contract("_ -> this")
      @NotNull
      @NotNull Builder hoverEvent(final @Nullable HoverEventSource<?> source);

      @Contract("_ -> this")
      @NotNull
      @NotNull Builder insertion(final @Nullable String insertion);

      @Contract("_ -> this")
      @NotNull
      default @NotNull Builder merge(final @NotNull Style that) {
         return this.merge(that, Style.Merge.all());
      }

      @Contract("_, _ -> this")
      @NotNull
      default @NotNull Builder merge(final @NotNull Style that, final Merge.@NotNull Strategy strategy) {
         return this.merge(that, strategy, Style.Merge.all());
      }

      @Contract("_, _ -> this")
      @NotNull
      default @NotNull Builder merge(final @NotNull Style that, final @NotNull Merge... merges) {
         return merges.length == 0 ? this : this.merge(that, Style.Merge.merges(merges));
      }

      @Contract("_, _, _ -> this")
      @NotNull
      default @NotNull Builder merge(final @NotNull Style that, final Merge.@NotNull Strategy strategy, final @NotNull Merge... merges) {
         return merges.length == 0 ? this : this.merge(that, strategy, Style.Merge.merges(merges));
      }

      @Contract("_, _ -> this")
      @NotNull
      default @NotNull Builder merge(final @NotNull Style that, final @NotNull Set<Merge> merges) {
         return this.merge(that, Style.Merge.Strategy.ALWAYS, merges);
      }

      @Contract("_, _, _ -> this")
      @NotNull
      @NotNull Builder merge(final @NotNull Style that, final Merge.@NotNull Strategy strategy, final @NotNull Set<Merge> merges);

      @Contract("_ -> this")
      @NotNull
      default @NotNull Builder apply(final @NotNull StyleBuilderApplicable applicable) {
         applicable.styleApply(this);
         return this;
      }

      @NotNull Style build();
   }

   public static enum Merge {
      COLOR,
      DECORATIONS,
      EVENTS,
      INSERTION,
      FONT;

      static final Set<Merge> ALL = merges(values());
      static final Set<Merge> COLOR_AND_DECORATIONS = merges(COLOR, DECORATIONS);

      public static @Unmodifiable @NotNull Set<Merge> all() {
         return ALL;
      }

      public static @Unmodifiable @NotNull Set<Merge> colorAndDecorations() {
         return COLOR_AND_DECORATIONS;
      }

      public static @Unmodifiable @NotNull Set<Merge> merges(final @NotNull Merge... merges) {
         return MonkeyBars.enumSet(Merge.class, merges);
      }

      /** @deprecated */
      @Deprecated
      @ScheduledForRemoval(
         inVersion = "5.0.0"
      )
      public static @Unmodifiable @NotNull Set<Merge> of(final @NotNull Merge... merges) {
         return MonkeyBars.enumSet(Merge.class, merges);
      }

      static boolean hasAll(final @NotNull Set<Merge> merges) {
         return merges.size() == ALL.size();
      }

      public static enum Strategy {
         ALWAYS,
         NEVER,
         IF_ABSENT_ON_TARGET;
      }
   }
}