/* Copyright 2009-2010 Yorba Foundation
 *
 * This software is licensed under the GNU Lesser General Public License
 * (version 2.1 or later).  See the COPYING file in this distribution. 
 */

namespace Model {
using Logging;

public interface TimeSystem : Object {
    public signal void geometry_changed();
    public abstract void calculate_pixel_step(float inc, float pixel_min, float pixel_div);
    public abstract int64 xpos_to_time(int x);
    public abstract int64 xsize_to_time(int x);
    public abstract int time_to_xpos(int64 time);
    public abstract int64 get_pixel_snap_time();
    public abstract int time_to_xsize(int64 time);
    public abstract float get_pixel_percentage();
    public abstract int get_start_token(int xsize);
    public abstract int get_next_position(int token);
    public abstract int get_pixel_height(int token);
    public abstract string? get_display_string(int token);
    public abstract int frame_to_xsize(int frame);
    public abstract int xsize_to_frame(int xsize);
    public abstract string get_time_string(int64 time);
    public abstract string get_time_duration(int64 time);
}

public abstract class TimeSystemBase : Object {
    public const int PIXEL_SNAP_INTERVAL = 10;

    public float pixel_percentage = 0.0f;
    public float pixels_per_second;
    public int64 pixel_snap_time;

    const int BORDER = 4;  // TODO: should use same value as timeline.  will happen when this gets
                           // refactored back into view code.

    abstract int[] get_timeline_seconds();
    abstract int correct_sub_second_value(float seconds, int div, int fps);

    protected int correct_seconds_value (float seconds, int div, int fps) {
        if (seconds < 1.0f) {
            return correct_sub_second_value(seconds, div, fps);
        }

        int i;
        int secs = (int) seconds;
        int [] timeline_seconds = get_timeline_seconds();
        for (i = timeline_seconds.length - 1; i > 0; i--) {
            if (secs <= timeline_seconds[i] &&
                secs >= timeline_seconds[i - 1]) {
                if ((div % (timeline_seconds[i] * fps)) == 0) {
                    break;
                }
                if ((div % (timeline_seconds[i - 1] * fps)) == 0) {
                    i--;
                    break;
                }
            }
        }
        return timeline_seconds[i] * fps;
    }

    public int64 get_pixel_snap_time() {
        return pixel_snap_time;
    }

    public float get_pixel_percentage() {
        return pixel_percentage;
    }

    public int64 xpos_to_time(int x) {
        return xsize_to_time(x - BORDER);
    }

    public int64 xsize_to_time(int size) {
        return (int64) ((float)(size * Gst.SECOND) / pixels_per_second);
    }

    public int time_to_xsize(int64 time) {
        return (int) (time * pixels_per_second / Gst.SECOND);
    }

    public int time_to_xpos(int64 time) {
        int pos = time_to_xsize(time) + BORDER;
        
        if (xpos_to_time(pos) != time)
            pos++;
        return pos;
    }
}

public class TimecodeTimeSystem : TimeSystem, TimeSystemBase {
    float pixels_per_frame;

    int small_pixel_frames = 0;
    int medium_pixel_frames = 0;
    int large_pixel_frames = 0;

    public Fraction frame_rate_fraction = Fraction(30000, 1001);

    override int correct_sub_second_value(float seconds, int div, int fps) {
        int frames = (int)(fps * seconds);
        if (frames == 0) {
            return 1;
        }

        if (div == 0) {
            div = fps;
        }

        int mod = div % frames;
        while (mod != 0) {
            mod = div % (++frames);
        }
        return frames;
    }

    public string get_time_string(int64 the_time) {
        string time;

        int frame = time_to_frame_with_rate(the_time, frame_rate_fraction);
        time = frame_to_string(frame, frame_rate_fraction);

        return time;
    }

    public string get_time_duration(int64 the_time) {
        // Timecode is already zero-based
        return get_time_string(the_time);
    }
    public void calculate_pixel_step(float inc, float pixel_min, float pixel_div) {
        int pixels_per_large = 300;
        int pixels_per_medium = 50;
        int pixels_per_small = 20;

        pixel_percentage += inc;
        if (pixel_percentage < 0.0f)
            pixel_percentage = 0.0f;
        else if (pixel_percentage > 1.0f)
            pixel_percentage = 1.0f;

        pixels_per_second = pixel_min * GLib.Math.powf(pixel_div, pixel_percentage);
        int fps = frame_rate_fraction.nearest_int();
        large_pixel_frames = correct_seconds_value(pixels_per_large / pixels_per_second, 0, fps);
        medium_pixel_frames = correct_seconds_value(pixels_per_medium / pixels_per_second, 
                                                    large_pixel_frames, fps);
        small_pixel_frames = correct_seconds_value(pixels_per_small / pixels_per_second, 
                                                    medium_pixel_frames, fps);

        if (small_pixel_frames == medium_pixel_frames) {
            int i = medium_pixel_frames;

            while (--i > 0) {
                if ((medium_pixel_frames % i) == 0) {
                    small_pixel_frames = i;
                    break;
                }
            }
        }

        pixels_per_frame = pixels_per_second / (float) fps;
        pixel_snap_time = xsize_to_time(PIXEL_SNAP_INTERVAL);
    }

    public int frame_to_xsize(int frame) {
        return ((int) (frame * pixels_per_frame));
    }

    public int xsize_to_frame(int xsize) {
        return (int) (xsize / pixels_per_frame);
    }

    public int get_start_token(int xsize) {
        int start_frame = xsize_to_frame(xsize);
        return large_pixel_frames * (start_frame / large_pixel_frames);
    }

    public int get_next_position(int token) {
        return token + small_pixel_frames;
    }

    public string? get_display_string(int frame) {
        if ((frame % large_pixel_frames) == 0) {
            return frame_to_time(frame, frame_rate_fraction).to_string();
        }
        return null;
    }

    public int get_pixel_height(int frame) {
        if ((frame % medium_pixel_frames) == 0) {
            if (medium_pixel_frames == small_pixel_frames &&
                    (medium_pixel_frames != large_pixel_frames &&
                    frame % large_pixel_frames != 0)) {
                return 2;
            }
            else {
                return 6;
            }
        } else {
            return 2;
        }
    }

    override int[] get_timeline_seconds() {
        return { 1, 2, 5, 10, 15, 20, 30, 60, 120, 300, 600, 900, 1200, 1800, 3600 };
    }
}

public interface TempoInformation {
    public abstract Fraction get_time_signature();
    public abstract int get_bpm();
    public signal void time_signature_changed(Fraction time_signature);
    public signal void bpm_changed(int bpm);
}

public class BarBeatTimeSystem : TimeSystem, TimeSystemBase {
    float pixels_per_sixteenth;

    int small_pixel_sixteenth = 0;
    int medium_pixel_sixteenth = 0;
    int large_pixel_sixteenth = 0;
    int[] timeline_bars = { 
            1, 2, 4, 8, 16, 24, 32, 64, 128, 256, 512, 768, 1024, 2048, 3192 
        };

    int bpm;
    Fraction time_signature;
    float bars_per_minute;
    float bars_per_second;
    int sixteenths_per_bar;
    int sixteenths_per_beat;

    public BarBeatTimeSystem(TempoInformation tempo_information) {
        bpm = tempo_information.get_bpm();
        time_signature = tempo_information.get_time_signature();
        tempo_information.bpm_changed.connect(on_bpm_changed);
        tempo_information.time_signature_changed.connect(on_time_signature_changed);
        set_constants();
    }

    void on_time_signature_changed(Fraction time_signature) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_time_signature_changed");
        this.time_signature = time_signature;
        set_constants();
    }

    void on_bpm_changed(int bpm) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_bpm_changed");
        this.bpm = bpm;
        set_constants();
    }

    void set_constants() {
        bars_per_minute = bpm / (float)time_signature.numerator;
        bars_per_second = bars_per_minute / 60.0f;

        sixteenths_per_beat = 16 / time_signature.denominator;
        sixteenths_per_bar = time_signature.numerator * sixteenths_per_beat;
        geometry_changed();
    }

    override int correct_sub_second_value(float bars, int div, int unused) {
        int sixteenths = (int)(sixteenths_per_bar * bars);

        if (sixteenths == 0) {
            return 1;
        }

        if (sixteenths > sixteenths_per_beat) {
            return sixteenths_per_beat;
        }

        if (sixteenths > 2) {
            return 2;
        }

        return 1;
    }

   string beats_to_string(int total_sixteenths, bool maximum_resolution, bool zero_based) {
        int number_of_measures = 
            (total_sixteenths / sixteenths_per_beat) / time_signature.numerator;

        int number_of_beats = 
            (total_sixteenths / sixteenths_per_beat) % time_signature.numerator;
        int number_of_sixteenths = total_sixteenths % sixteenths_per_beat;
        if (!zero_based) {
            ++number_of_measures;
            ++number_of_beats;
            ++number_of_sixteenths;
        }
        float pixels_per_bar = pixels_per_second / bars_per_second;
        float pixels_per_large_gap = large_pixel_sixteenth * pixels_per_sixteenth;
        if (maximum_resolution ||
            ((pixels_per_large_gap < pixels_per_sixteenth * sixteenths_per_beat) &&
            number_of_sixteenths > 1)) {
            return "%d.%d.%d".printf(number_of_measures, number_of_beats, number_of_sixteenths);
        } else if (pixels_per_large_gap < pixels_per_bar && number_of_beats > 1) {
            return "%d.%d".printf(number_of_measures, number_of_beats);
        } else {
            return "%d".printf(number_of_measures);
        }
    }

    public string get_time_string(int64 the_time) {
        double beats_per_second = bpm / 60.0;
        double sixteenths_per_second = sixteenths_per_beat * beats_per_second;
        double sixteenths_per_nanosecond = sixteenths_per_second / Gst.SECOND;
        int total_beats = (int)(the_time * sixteenths_per_nanosecond);
        return beats_to_string(total_beats, true, false);
    }

    public string get_time_duration(int64 the_time) {
        double beats_per_second = bpm / 60.0;
        double sixteenths_per_second = sixteenths_per_beat * beats_per_second;
        double sixteenths_per_nanosecond = sixteenths_per_second / Gst.SECOND;
        int total_beats = (int)(the_time * sixteenths_per_nanosecond);
        if (total_beats == 0 && the_time > 0) {
            // round up
            total_beats = 1;
        }
        return beats_to_string(total_beats, true, true);
    }

    public void calculate_pixel_step(float inc, float pixel_min, float pixel_div) {
        int pixels_per_large = 80;
        int pixels_per_medium = 40;
        int pixels_per_small = 20;

        pixel_percentage += inc;
        if (pixel_percentage < 0.0f) {
            pixel_percentage = 0.0f;
        } else if (pixel_percentage > 1.0f) {
            pixel_percentage = 1.0f;
        }

        pixels_per_second = pixel_min * GLib.Math.powf(pixel_div, pixel_percentage);
        float pixels_per_bar = pixels_per_second / bars_per_second;
        large_pixel_sixteenth = correct_seconds_value(
            pixels_per_large / pixels_per_bar, 0, sixteenths_per_bar);

        medium_pixel_sixteenth = correct_seconds_value(pixels_per_medium / pixels_per_bar,
            large_pixel_sixteenth, sixteenths_per_bar);
        small_pixel_sixteenth = correct_seconds_value(pixels_per_small / pixels_per_bar,
            medium_pixel_sixteenth, sixteenths_per_bar);
        if (small_pixel_sixteenth == medium_pixel_sixteenth) {
            int i = medium_pixel_sixteenth;

            while (--i > 0) {
                if ((medium_pixel_sixteenth % i) == 0) {
                    small_pixel_sixteenth = i;
                    break;
                }
            }
        }

        pixels_per_sixteenth = pixels_per_bar / (float) sixteenths_per_bar;
        pixel_snap_time = xsize_to_time(PIXEL_SNAP_INTERVAL);
    }

    public int frame_to_xsize(int frame) {
        return ((int) (frame * pixels_per_sixteenth));
    }

    public int xsize_to_frame(int xsize) {
        return (int) (xsize / pixels_per_sixteenth);
    }

    public int get_start_token(int xsize) {
        int start_frame = xsize_to_frame(xsize);
        return large_pixel_sixteenth * (start_frame / large_pixel_sixteenth);
    }

    public int get_next_position(int token) {
        return token + small_pixel_sixteenth;
    }

    public string? get_display_string(int frame) {
        if ((frame % large_pixel_sixteenth) == 0) {
            return beats_to_string(frame, false, false);
        }
        return null;
    }

    public int get_pixel_height(int frame) {
        if ((frame % medium_pixel_sixteenth) == 0) {
            if (medium_pixel_sixteenth == small_pixel_sixteenth &&
                    (medium_pixel_sixteenth != large_pixel_sixteenth &&
                    frame % large_pixel_sixteenth != 0)) {
                return 2;
            }
            else {
                return 6;
            }
        } else {
            return 2;
        }
    }

    override int[] get_timeline_seconds() {
        return timeline_bars;
    }
}
}