import {Fraction} from "../../../Common/DataObjects/fraction";
import {SourceMeasure} from "../SourceMeasure";
import {InstantaniousTempoExpression} from "./instantaniousTempoExpression";
import {PlacementEnum} from "./abstractExpression";
import {OSMDFontStyles} from "../../../Common/Enums/osmdFontStyles";
import {AbstractTempoExpression} from "./abstractTempoExpression";
import {ContinuousTempoExpression} from "./ContinuousExpressions/continuousTempoExpression";

export class MultiTempoExpression implements IComparable<MultiTempoExpression>
{
    constructor(sourceMeasure: SourceMeasure, timestamp: Fraction) {
        this.sourceMeasure = sourceMeasure;
        this.timestamp = timestamp;
    }
    private timestamp: Fraction;
    private sourceMeasure: SourceMeasure;
    private instantaniousTempo: InstantaniousTempoExpression;
    private continuousTempo: ContinuousTempoExpression;
    private expressions: Array<TempoExpressionEntry> = new Array<TempoExpressionEntry>();
    private combinedExpressionsText: string;
    public get Timestamp(): Fraction {
        return this.timestamp;
    }
    public get AbsoluteTimestamp(): Fraction {
        return this.sourceMeasure.AbsoluteTimestamp + this.timestamp;
    }
    public get SourceMeasureParent(): SourceMeasure {
        return this.sourceMeasure;
    }
    public set SourceMeasureParent(value: SourceMeasure) {
        this.sourceMeasure = value;
    }
    public get InstantaniousTempo(): InstantaniousTempoExpression {
        return this.instantaniousTempo;
    }
    public get ContinuousTempo(): ContinuousTempoExpression {
        return this.continuousTempo;
    }
    public get EntriesList(): Array<TempoExpressionEntry> {
        return this.expressions;
    }
    public get CombinedExpressionsText(): string {
        return this.combinedExpressionsText;
    }
    public set CombinedExpressionsText(value: string) {
        this.combinedExpressionsText = value;
    }
    public getPlacementOfFirstEntry(): PlacementEnum {
        var placement: PlacementEnum = PlacementEnum.Above;
        if (this.expressions.length > 0) {
            if (this.expressions[0].expression instanceof InstantaniousTempoExpression)
                placement = (<InstantaniousTempoExpression>(this.expressions[0].expression)).Placement;
            else if (this.expressions[0].expression instanceof ContinuousTempoExpression)
                placement = (<ContinuousTempoExpression>(this.expressions[0].expression)).Placement;
        }
        return placement;
    }
    public getFontstyleOfFirstEntry(): OSMDFontStyles {
        var fontStyle: OSMDFontStyles = OSMDFontStyles.Regular;
        if (this.expressions[0].expression instanceof InstantaniousTempoExpression)
            fontStyle = OSMDFontStyles.Bold;
        else if (this.expressions[0].expression instanceof ContinuousTempoExpression)
            fontStyle = OSMDFontStyles.Italic;
        return fontStyle;
    }
    public getFirstEntry(graphicalLabel: GraphicalLabel): AbstractGraphicalExpression {
        var indexOfFirstNotInstDynExpr: number = 0;
        if (this.expressions.length > 0) {
            if (this.expressions[indexOfFirstNotInstDynExpr].expression instanceof InstantaniousTempoExpression)
                return new GraphicalInstantaniousTempoExpression(<InstantaniousTempoExpression>(this.expressions[indexOfFirstNotInstDynExpr].expression), graphicalLabel);
            else if (this.expressions[indexOfFirstNotInstDynExpr].expression instanceof ContinuousTempoExpression)
                return new GraphicalContinuousTempoExpression(<ContinuousTempoExpression>(this.expressions[indexOfFirstNotInstDynExpr].expression), graphicalLabel);
            else return null;
        }
        return null;
    }
    public addExpression(abstractTempoExpression: AbstractTempoExpression, prefix: string): void {
        if (abstractTempoExpression instanceof InstantaniousTempoExpression) {
            this.instantaniousTempo = <InstantaniousTempoExpression>abstractTempoExpression;
        }
        else if (abstractTempoExpression instanceof ContinuousTempoExpression) {
            this.continuousTempo = <ContinuousTempoExpression>abstractTempoExpression;
        }
        var tempoExpressionEntry: TempoExpressionEntry = new TempoExpressionEntry();
        tempoExpressionEntry.prefix = prefix;
        tempoExpressionEntry.expression = abstractTempoExpression;
        tempoExpressionEntry.label = abstractTempoExpression.Label;
        this.expressions.push(tempoExpressionEntry);
    }
    public CompareTo(other: MultiTempoExpression): number {
        if (this.SourceMeasureParent.MeasureNumber > other.SourceMeasureParent.MeasureNumber)
            return 1;
        if (this.SourceMeasureParent.MeasureNumber < other.SourceMeasureParent.MeasureNumber)
            return -1;
        else {
            if (this.Timestamp.RealValue > other.Timestamp.RealValue)
                return 1;
            if (this.Timestamp.RealValue < other.Timestamp.RealValue)
                return -1;
            else return 0;
        }
    }
}
export class TempoExpressionEntry {
    public prefix: string;
    public expression: AbstractTempoExpression;
    public label: string;
}