import { DancerIdentity } from "../danceCommon.js";
import { SemanticPosition, PositionKind, ShortLinesPosition, CirclePosition, CircleSide, Facing } from "../interpreterCommon.js";
import { LowLevelMove, SemanticAnimationKind } from "../lowLevelMove.js";
import { Hand } from "../rendererConstants.js";
import { ISingleVariantMoveInterpreter, LowLevelMovesForAllDancers, MoveInterpreter, MoveInterpreterCtorArgs, PartialLowLevelMove, SemanticPositionsForAllDancers, SingleVariantMoveInterpreter, moveInterpreters } from "./_moveInterpreter.js";
import { dancerIsPair } from "../libfigure/util.js";

const moveName = "hey";

type HeyStep = {
  kind: "StandStill" | "Loop" | "CenterPass" | "EndsPassIn" | "EndsPassOut" | "Ricochet",
  endPosition: SemanticPosition,
}

function fixupHeyOtherPath(withoutOtherPath: Map<DancerIdentity, (LowLevelMove & { heyStep?: HeyStep })[]>): Map<DancerIdentity, LowLevelMove[]> {
  const numSteps = withoutOtherPath.get(DancerIdentity.OnesLark)!.length;
  for (let i = 0; i < numSteps; i++) {
    for (const id of withoutOtherPath.keys()) {
      const lowLevelMove = withoutOtherPath.get(id)![i];
      if (lowLevelMove.movementPattern.kind !== SemanticAnimationKind.PassBy
        || !lowLevelMove.heyStep
        || lowLevelMove.movementPattern.otherPath) {
        continue;
      }

      const heyStepKind = lowLevelMove.heyStep.kind;
      let foundPair = false;
      for (const otherId of withoutOtherPath.keys()) {
        const otherLowLevelMove = withoutOtherPath.get(otherId)![i];
        if (id === otherId
          || otherLowLevelMove.movementPattern.kind !== SemanticAnimationKind.PassBy
          || !otherLowLevelMove.heyStep
          || otherLowLevelMove.movementPattern.otherPath) {
          continue;
        }

        const otherHeyStepKind = otherLowLevelMove.heyStep.kind;

        if (heyStepKind === "CenterPass" && otherHeyStepKind === "CenterPass"
          || (lowLevelMove.startPosition.which.leftRightSide() === otherLowLevelMove.startPosition.which.leftRightSide()
            && (heyStepKind === "EndsPassIn" && otherHeyStepKind === "EndsPassOut"
              || heyStepKind === "EndsPassOut" && otherHeyStepKind === "EndsPassIn"))) {
          lowLevelMove.movementPattern.otherPath = {
            start: { ...otherLowLevelMove.startPosition, setOffset: lowLevelMove.startPosition.setOffset, lineOffset: lowLevelMove.startPosition.lineOffset },
            end: { ...otherLowLevelMove.endPosition, setOffset: lowLevelMove.endPosition.setOffset, lineOffset: lowLevelMove.endPosition.lineOffset },
          }
          otherLowLevelMove.movementPattern.otherPath = {
            start: { ...lowLevelMove.startPosition, setOffset: otherLowLevelMove.startPosition.setOffset, lineOffset: otherLowLevelMove.startPosition.lineOffset },
            end: { ...lowLevelMove.endPosition, setOffset: otherLowLevelMove.endPosition.setOffset, lineOffset: otherLowLevelMove.endPosition.lineOffset },
          }
          foundPair = true;
          break;
        }
      }

      if (!foundPair && heyStepKind === "EndsPassOut") {
        // Then other is standing still.
        const pos = {
          ...([...withoutOtherPath.values()]
            .map(otherMoves => otherMoves[i])
            .filter(m => m.movementPattern.kind === SemanticAnimationKind.StandStill
              && m.endPosition.which.leftRightSide() === lowLevelMove.endPosition.which.leftRightSide())
          [0].endPosition),
          setOffset: lowLevelMove.startPosition.setOffset, lineOffset: lowLevelMove.startPosition.lineOffset
        }
        lowLevelMove.movementPattern.otherPath = { start: pos, end: pos };
      }
    }

    for (const id of withoutOtherPath.keys()) {
      const lowLevelMove = withoutOtherPath.get(id)![i];
      if (lowLevelMove.movementPattern.kind === SemanticAnimationKind.PassBy
        && !lowLevelMove.movementPattern.otherPath) {
        throw new Error("Failed to fill in otherPath for " + id + " on hey step " + i);
      }
    }
  }

  // Object was mutated.
  return withoutOtherPath;
}

class HeySingleVariant extends SingleVariantMoveInterpreter<Hey, typeof moveName> {
  heyStepToPartialLowLevelMove(heyStep: HeyStep): PartialLowLevelMove & { heyStep: HeyStep } {
    return {
      beats: this.moveInterpreter.heyPartBeats,
      // TODO use circle positions on ends? ... unless hey ends in a box the gnat or similar...
      endPosition: heyStep.endPosition,
      movementPattern: heyStep.kind === "StandStill" ? {
        kind: SemanticAnimationKind.StandStill,
      } : heyStep.kind === "Loop" ? {
        // TODO Loop should probably be its own kind? Or RotateAround?
        kind: SemanticAnimationKind.Linear,
        minRotation: this.moveInterpreter.endsShoulder === Hand.Right ? +180 : -180,
      } : heyStep.kind === "Ricochet" ? {
        // TODO This is a hack.
        kind: SemanticAnimationKind.PassBy,
        around: heyStep.endPosition.which.leftRightSide(),
        withHands: false,
        otherPath: "Swap",
        facing: "Start",
        side: this.moveInterpreter.endsShoulder,
      } : {
        kind: SemanticAnimationKind.PassBy,
        around: heyStep.kind === "CenterPass" ? "Center" : heyStep.endPosition.which.leftRightSide(),
        withHands: false,
        side: heyStep.kind === "CenterPass" ? this.moveInterpreter.centerShoulder : this.moveInterpreter.endsShoulder,
        facing: "Start",
        otherPath: undefined!, // Placeholder, fixup later.
      },
      heyStep,
    };
  }

  continueHey(prevStep: HeyStep, stepsLeft: number,
      { beenInCenter, endsInCircle, inCenterFirst }:
        { beenInCenter: boolean, endsInCircle: boolean, inCenterFirst: boolean }): HeyStep {
    // TODO Not sure why type checker requires rechecking this here.
    if (this.move.move !== "hey") throw new Error("Unreachable.");

    // Continuing hey so everyone is either passing (in center or on ends) or looping on ends.
    if (prevStep.endPosition.kind === PositionKind.Circle) {
      if (prevStep.endPosition.facing === prevStep.endPosition.which.facingAcross()) {
        if (stepsLeft === 0) {
          return {
            kind: "StandStill",
            endPosition: prevStep.endPosition,
          }
        }
        return {
          kind: "EndsPassIn",
          endPosition: {
            kind: PositionKind.ShortLines,
            which: prevStep.endPosition.which.isLeft() ? ShortLinesPosition.MiddleLeft : ShortLinesPosition.MiddleRight,
            facing: prevStep.endPosition.which.facingAcross(),
            setOffset: prevStep.endPosition.setOffset,
            lineOffset: prevStep.endPosition.lineOffset,
          },
        }
      }
      else {
        if (stepsLeft === 1 && !endsInCircle) {
          return {
            kind: "Loop",
            endPosition: {
              kind: PositionKind.ShortLines,
              which: prevStep.endPosition.which.isLeft() ? ShortLinesPosition.FarLeft : ShortLinesPosition.FarRight,
              facing: prevStep.endPosition.which.facingAcross(),
              setOffset: prevStep.endPosition.setOffset,
              lineOffset: prevStep.endPosition.lineOffset,
            },
          }
        }
        return {
          kind: "Loop",
          endPosition: {
            ...prevStep.endPosition,
            which: prevStep.endPosition.which.swapUpAndDown(),
            facing: prevStep.endPosition.which.facingAcross()
          },
        }
      }
    }
    else if (prevStep.endPosition.kind === PositionKind.ShortLines) {
      const isFacingSide = prevStep.endPosition.facing === prevStep.endPosition.which.facingSide();
      const inMiddle = prevStep.endPosition.which.isMiddle();
      if (!inMiddle && !isFacingSide) {
        return {
          kind: "Loop",
          endPosition: { ...prevStep.endPosition, facing: prevStep.endPosition.which.facingSide() },
        }
      } else if (inMiddle && isFacingSide) {
        return {
          kind: "EndsPassOut",
          endPosition: {
            ...prevStep.endPosition,
            kind: PositionKind.Circle,
            which: prevStep.endPosition.which.isLeft()
              ? (this.moveInterpreter.endsShoulder === Hand.Right ? CirclePosition.TopLeft : CirclePosition.BottomLeft)
              : (this.moveInterpreter.endsShoulder === Hand.Right ? CirclePosition.BottomRight : CirclePosition.TopRight),
          },
        }
      }
      else if (!isFacingSide) {
        const rico = inCenterFirst
          ? beenInCenter
            ? this.move.parameters.rico3
            : this.move.parameters.rico1
          : beenInCenter
            ? this.move.parameters.rico4
            : this.move.parameters.rico2;

        if (rico) {
          const onLeftSide = prevStep.endPosition.which.isLeft();
          return {
            kind: "Ricochet",
            endPosition: {
              ...prevStep.endPosition,
              kind: PositionKind.Circle,
              which: CirclePosition.fromSides(prevStep.endPosition.which.leftRightSide(),
                // TODO might be swapped
                (this.moveInterpreter.endsShoulder === Hand.Left) === onLeftSide ? CircleSide.Top : CircleSide.Bottom),
              facing: onLeftSide ? Facing.Left : Facing.Right,
            }
          }
        } else {
          return {
            kind: "CenterPass",
            endPosition: {
              ...prevStep.endPosition,
              which: prevStep.endPosition.which.swapSides()
            },
          }
        }
      }
      else {
        return {
          kind: inMiddle ? "EndsPassOut" : "EndsPassIn",
          endPosition: {
            ...prevStep.endPosition,
            which: prevStep.endPosition.which.swapOnSide()
          },
        }
      }
    } else {
      throw new Error("Unexpected PositionKind: " + (<any>prevStep.endPosition).kind);
    }
  }

  moveAsLowLevelMoves(): LowLevelMovesForAllDancers {
    return fixupHeyOtherPath(this.handleMove(({ id, startPos }) => {
      const endsInCircle = startPos.kind === PositionKind.Circle;

      const inCenterFirst = this.moveInterpreter.firstPassInCenter && (this.findPairOpposite(this.move.parameters.who, id) !== null)
        || !!this.move.parameters.who2 && (this.findPairOpposite(this.move.parameters.who2, id) !== null);

      let firstHeyStep: HeyStep;
      let startingPos: SemanticPosition;
      if (this.moveInterpreter.firstPassInCenter) {
        if (startPos.kind !== PositionKind.Circle) {
          throw new Error("Hey starting in center not from circle is unsupported.");
        }
        startingPos = {
          kind: startPos.kind,
          which: startPos.which,
          facing: startPos.which.isLeft() ? Facing.Right : Facing.Left,
          setOffset: startPos.setOffset,
          lineOffset: startPos.lineOffset,
        };
        if (inCenterFirst) {
          if (this.move.parameters.rico1) {
            firstHeyStep = {
              kind: "Ricochet",
              endPosition: {
                kind: PositionKind.Circle,
                which: startPos.which.swapUpAndDown(),
                facing: startPos.which.facingOut(),
                setOffset: startPos.setOffset,
                lineOffset: startPos.lineOffset,
              }
            };
          } else {
            firstHeyStep = {
              kind: "CenterPass",
              endPosition: {
                kind: PositionKind.ShortLines,
                which: startPos.which.isLeft() ? ShortLinesPosition.MiddleRight : ShortLinesPosition.MiddleLeft,
                facing: startingPos.facing,
                setOffset: startPos.setOffset,
                lineOffset: startPos.lineOffset,
              }
            };
          }
        } else {
          firstHeyStep = {
            kind: "StandStill",
            endPosition: startingPos,
          }
        }
      } else {
        if (startPos.kind !== PositionKind.ShortLines) {
          throw new Error("Hey with first pass on ends must start approximately in short lines.");
        }

        const startFacing = startPos.which.facingSide();
        startingPos = {
          kind: startPos.kind,
          which: startPos.which,
          facing: startFacing,
          setOffset: startPos.setOffset,
          lineOffset: startPos.lineOffset,
        };
        firstHeyStep = {
          kind: startingPos.which.isMiddle() ? "EndsPassOut" : "EndsPassIn",
          endPosition: { ...startingPos, which: startPos.which.swapOnSide() },
        }
      }

      const heySteps: HeyStep[] = [firstHeyStep];
      let beenInCenter = firstHeyStep.kind === "CenterPass" || firstHeyStep.kind === "Ricochet";
      for (let i = 1; i < this.moveInterpreter.heyParts; i++) {
        const nextHeyStep = this.continueHey(heySteps[i - 1], this.moveInterpreter.heyParts - i - 1, {beenInCenter, endsInCircle, inCenterFirst});
        beenInCenter ||= nextHeyStep.kind === "CenterPass" || nextHeyStep.kind === "Ricochet";
        heySteps.push(nextHeyStep);
      }
      return this.combine(heySteps.map(s => this.heyStepToPartialLowLevelMove(s)), { ...startingPos, hands: undefined });
    }));
  }
}

class Hey extends MoveInterpreter<typeof moveName> {
  public readonly heyParts: number;
  public readonly heyPartBeats: number;
  public readonly firstPassInCenter: boolean;
  public readonly centerShoulder: Hand;
  public readonly endsShoulder: Hand;

  constructor(args: MoveInterpreterCtorArgs<typeof moveName>) {
    super(args);

    if (this.move.parameters.dir !== "across") {
      throw new Error("Unsupported hey direction: " + this.move.parameters.dir);
    }

    if (typeof this.move.parameters.until === "string") {
      switch (this.move.parameters.until) {
        case "half":
          this.heyParts = 4;
          break;
        case "full":
          this.heyParts = 8;
          break;
        // TODO Are these right? Can it sometimes be 1 or 3 instead of 2?
        case "less than half":
          this.heyParts = 2;
          break;
        case "between half and full":
          this.heyParts = 6;
        default:
          throw new Error("Unsupported hey 'until': " + this.move.parameters.until);
      }
    }
    else {
      // TODO Is this actually this simple?
      this.heyParts = this.move.parameters.until.time === 1 ? 2 : 6;
      //throw new Error("Unsupported hey 'until': " + this.move.parameters.until.dancer + " time " + this.move.parameters.until.time);
    }
    this.heyPartBeats = this.move.beats / this.heyParts;
    // TODO is this right?
    this.firstPassInCenter = dancerIsPair(this.move.parameters.who);
    this.centerShoulder = this.firstPassInCenter === this.move.parameters.shoulder ? Hand.Right : Hand.Left;
    this.endsShoulder = this.centerShoulder.opposite();
  }

  buildSingleVariantMoveInterpreter(startingPos: SemanticPositionsForAllDancers): ISingleVariantMoveInterpreter {
    return new HeySingleVariant(this, startingPos);
  }
}

moveInterpreters.set(moveName, Hey);