/*

timespan.mjs - <short description TODO>

Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/timespan.mjs>

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/

import Fraction from './fraction.mjs';

export class TimeSpan {

  constructor(begin, end) {

    this.begin = Fraction(begin);

    this.end = Fraction(end);

  }

  get spanCycles() {

    const spans = [];

    var begin = this.begin;

    const end = this.end;

    const end_sam = end.sam();

    // Support zero-width timespans

    if (begin.equals(end)) {

      return [new TimeSpan(begin, end)];

    }

    while (end.gt(begin)) {

      // If begin and end are in the same cycle, we're done.

      if (begin.sam().equals(end_sam)) {

        spans.push(new TimeSpan(begin, this.end));

        break;

      }

      // add a timespan up to the next sam

      const next_begin = begin.nextSam();

      spans.push(new TimeSpan(begin, next_begin));

      // continue with the next cycle

      begin = next_begin;

    }

    return spans;

  }

  get duration() {

    return this.end.sub(this.begin);

  }

  cycleArc() {

    // Shifts a timespan to one of equal duration that starts within cycle zero.

    // (Note that the output timespan probably does not start *at* Time 0 --

    // that only happens when the input Arc starts at an integral Time.)

    const b = this.begin.cyclePos();

    const e = b.add(this.duration);

    return new TimeSpan(b, e);

  }

  withTime(func_time) {

    // Applies given function to both the begin and end time of the timespan"""

    return new TimeSpan(func_time(this.begin), func_time(this.end));

  }

  withEnd(func_time) {

    // Applies given function to the end time of the timespan"""

    return new TimeSpan(this.begin, func_time(this.end));

  }

  withCycle(func_time) {

    // Like withTime, but time is relative to relative to the cycle (i.e. the

    // sam of the start of the timespan)

    const sam = this.begin.sam();

    const b = sam.add(func_time(this.begin.sub(sam)));

    const e = sam.add(func_time(this.end.sub(sam)));

    return new TimeSpan(b, e);

  }

  intersection(other) {

    // Intersection of two timespans, returns undefined if they don't intersect.

    const intersect_begin = this.begin.max(other.begin);

    const intersect_end = this.end.min(other.end);

    if (intersect_begin.gt(intersect_end)) {

      return undefined;

    }

    if (intersect_begin.equals(intersect_end)) {

      // Zero-width (point) intersection - doesn't intersect if it's at the end of a

      // non-zero-width timespan.

      if (intersect_begin.equals(this.end) && this.begin.lt(this.end)) {

        return undefined;

      }

      if (intersect_begin.equals(other.end) && other.begin.lt(other.end)) {

        return undefined;

      }

    }

    return new TimeSpan(intersect_begin, intersect_end);

  }

  intersection_e(other) {

    // Like 'sect', but raises an exception if the timespans don't intersect.

    const result = this.intersection(other);

    if (result == undefined) {

      throw 'TimeSpans do not intersect';

    }

    return result;

  }

  midpoint() {

    return this.begin.add(this.duration.div(Fraction(2)));

  }

  equals(other) {

    return this.begin.equals(other.begin) && this.end.equals(other.end);

  }

  show() {

    return this.begin.show() + ' → ' + this.end.show();

  }

}

export default TimeSpan;