/* 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. 
 */

using Logging;

namespace Model {

public abstract class Track : Object {
    protected weak Project project;
    public Gee.ArrayList<Clip> clips = new Gee.ArrayList<Clip>();  // all clips, sorted by time
    public string display_name;
    bool is_selected;

    public signal void clip_added(Clip clip, bool select);
    public signal void clip_removed(Clip clip);

    public signal void track_renamed(Track track);
    public signal void track_selection_changed(Track track);
    public signal void track_hidden(Track track);
    public signal void track_removed(Track track);
    public signal void error_occurred(string major_error, string? minor_error);

    public Track(Project project, string display_name) {
        this.project = project;
        this.display_name = display_name;
    }

    protected abstract string name();
    public abstract MediaType media_type();

    public void hide() {
        track_hidden(this);
    }

    public bool contains_clipfile(ClipFile f) {
        foreach (Clip c in clips) {
            if (c.clipfile == f)
                return true;
        }
        return false;
    }

    protected abstract bool check(Clip clip);

    public int64 get_time_from_pos(Clip clip, bool after) {
        if (after)
            return clip.start + clip.duration;
        else
            return clip.start;
    }

    int get_clip_from_time(int64 time) {
        for (int i = 0; i < clips.size; i++) {
            if (time >= clips[i].start &&
                time < clips[i].end)
                return i;
        }
        return -1;
    }

    public int64 snap_clip(Clip c, int64 span) {
        foreach (Clip cl in clips) {
            int64 new_start = c.snap(cl, span);
            if (new_start != c.start) {
                return new_start;
            }
        }
        return c.start;
    }

    public bool snap_coord(out int64 coord, int64 span) {
        foreach (Clip c in clips) {
            if (c.snap_coord(out coord, span))
                return true;
        }
        return false;
    }

    public bool clip_is_near(Model.Clip clip, int64 range, out int64 adjustment) {
        foreach (Clip potential_clip in clips) {
            if (potential_clip != clip) {
                int64 difference = clip.start - potential_clip.end;
                if (difference.abs() < range) {
                    adjustment = -difference;
                    return true;
                }

                difference = potential_clip.start - clip.end;
                if (difference.abs() < range) {
                    adjustment = difference;
                    return true;
                }
            }
        }
        return false;
    }

    int get_insert_index(int64 time) {
        int end_ret = 0;
        for (int i = 0; i < clips.size; i++) {
            Clip c = clips[i];

            if (time >= c.start) {
                if (time < c.start + c.duration/2)
                    return i;
                else if (time < c.start + c.duration)
                    return i + 1;
                else
                    end_ret ++;
            }
        }
        return end_ret;
    }

    // This is called to find the first gap after a start time
    public Gap find_first_gap(int64 start) {
        int64 new_start = 0;
        int64 new_end = int64.MAX;

        foreach (Clip c in clips) {
            if (c.start > new_start &&
                c.start > start) {
                new_end = c.start;
                break;
            }
            new_start = c.end;
        }
        return new Gap(new_start, new_end);
    }

    // This is always called with the assumption that we are not on a clip
    int get_gap_index(int64 time) {
        int i = 0;
        while (i < clips.size) {
            if (time <= clips[i].start)
                break;
            i++;
        }
        return i;
    }

    // If we are not on a valid gap (as in, a space between two clips or between the start
    // and the first clip), we return an empty (and invalid) gap
    public void find_containing_gap(int64 time, out Gap g) {
        g = new Gap(0, 0);

        int index = get_gap_index(time);
        if (index < clips.size) {
            g.start = index > 0 ? clips[index - 1].end : 0;
            g.end = clips[index].start;
        }
    }

    public Clip? find_overlapping_clip(int64 start, int64 length) {
        for (int i = 0; i < clips.size; i++) {
            Clip c = clips[i];
            if (c.overlap_pos(start, length))
                return c;
        }
        return null;
    }

    public Clip? find_nearest_clip_edge(int64 time, out bool after) {
        int limit = clips.size * 2;
        int64 prev_time = clips[0].start;

        for (int i = 1; i < limit; i++) {
            Clip c = clips[i / 2];
            int64 t;

            if (i % 2 == 0)
                t = c.start;
            else
                t = c.end;

            if (t > time) {
                if (t - time < time - prev_time) {
                    after = ((i % 2) != 0);
                    return clips[i / 2];
                } else {
                    after = ((i % 2) == 0);
                    return clips[(i - 1) / 2];
                }
            }
            prev_time = t;
        }

        after = true;
        return clips[clips.size - 1];
    }

    void do_clip_overwrite(Clip c) {
        int start_index = get_clip_from_time(c.start);
        int end_index = get_clip_from_time(c.end);

        if (end_index >= 0) {
            int64 diff = c.end - clips[end_index].start;
            if (end_index == start_index) {
                if (c == clips[end_index]) {
                    return;
                }

                if (diff > 0) {
                    Clip cl = new Clip(clips[end_index].clipfile, clips[end_index].type, 
                                    clips[end_index].name, c.end, 
                                    clips[end_index].media_start + diff,
                                    clips[end_index].duration - diff, false);
                    append_at_time(cl, cl.start, false);
                }
            } else {
                trim(clips[end_index], diff, Gdk.WindowEdge.WEST);
            }
        }
        if (start_index >= 0 && clips[start_index] != c) {
            int64 delta = clips[start_index].end - c.start;
            trim(clips[start_index], -delta, Gdk.WindowEdge.EAST);
            }

        int i = 0;
        // TODO: This code assumes that when a delete happens, it is reflected immediately.
        // When we are in an undo (or redo) deleting will happen later.  It would be better
        // for callers not to have to deal with this problem.  Too large of a change for now.
        if (!project.undo_manager.in_undo) {
            while (i < clips.size) {
                if (clips[i] != c && 
                    clips[i].start >= c.start &&
                    clips[i].end <= c.end) {
                    delete_clip(clips[i]);
                }
                else
                    i++;
            }
        }
    }

    public void move(Clip c, int64 pos, int64 original_time) {
        Command command = new ClipAddCommand(this, c, original_time, pos);
        project.do_command(command);
    }

    public void _move(Clip c, int64 pos) {
        if (pos < 0) {
            pos = 0;
        }
        c.start = pos;
        do_clip_overwrite(c);

        insert_clip_into_array(c, get_insert_index(c.start));
        project.reseek();
    }

    public void add(Clip c, int64 pos, bool select) {
        if (!check(c))
            return;

        _move(c, pos);
        clip_added(c, select);
    }

    public virtual void on_clip_updated(Clip clip) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_updated");    
    }

    public void do_clip_paste(Clip clip, int64 position) {
        append_at_time(clip, position, true);
    }

    public Clip? get_clip(int i) {
        if (i < 0 || i >= clips.size)
            error("get_clip: Invalid index! %d (%d)", i, clips.size);
        return clips[i];
    }

    public int get_clip_index(Clip c) {
        for (int i = 0; i < clips.size; i++) {
            if (clips[i] == c) {
                return i;
            }
        }
        return -1;
    }

    public Clip? get_clip_by_position(int64 pos) {
        int length = clips.size;

        for (int i = length - 1; i >= 0; i--)
            if (clips[i].start < pos)
                return pos >= clips[i].end ? null : clips[i];
        return null;
    }

    public int64 get_length() {
        return clips.size == 0 ? 0 : clips[clips.size - 1].start + clips[clips.size - 1].duration;
    }

    public void _append_at_time(Clip c, int64 time, bool select) {
        add(c, time, select);
    }

    public void append_at_time(Clip c, int64 time, bool select) {
        Command command = new ClipCommand(ClipCommand.Action.APPEND, this, c, time, select);
        project.do_command(command);
    }

    public void delete_clip(Clip clip) {
        Command clip_command = new ClipCommand(ClipCommand.Action.DELETE, 
            this, clip, clip.start, false);
        project.do_command(clip_command);
    }

    public void _delete_clip(Clip clip) {
        int index = get_clip_index(clip);
        assert(index != -1);
        clips.remove_at(index);

        clip.removed(clip);
        clip_removed(clip);
    }

    public void delete_gap(Gap g) {
        project.reseek();
    }

    public void remove_clip_from_array(Clip pos) {
        clips.remove(pos);
    }

    void insert_clip_into_array(Clip c, int pos) {
        c.updated.connect(on_clip_updated);
        clips.insert(pos, c);
    }

    public void delete_all_clips() {
        uint size = clips.size;
        for (int i = 0; i < size; i++) { 
            delete_clip(clips[0]);
        }
        project.media_engine.go(0);
    }

    public void revert_to_original(Clip clip) {
        Command command = new ClipRevertCommand(this, clip);
        project.do_command(command);
    }

    public void _revert_to_original(Clip c) {
        int index = get_clip_index(c);
        if (index == -1)
            error("revert_to_original: Clip not in track array!");

        c.set_media_start_duration(0, c.clipfile.length);

        project.media_engine.go(c.start);
    }

    public bool are_contiguous_clips(int64 position) {
        Clip right_clip = get_clip_by_position(position + 1);
        Clip left_clip = get_clip_by_position(position - 1);

        return left_clip != null && right_clip != null && 
            left_clip != right_clip &&
            left_clip.clipfile == right_clip.clipfile &&
            left_clip.end == right_clip.start;
    }

    public void split_at(int64 position) {
        Command command = new ClipSplitCommand(ClipSplitCommand.Action.SPLIT, this, position);
        project.do_command(command);
    }

    public void _split_at(int64 position) {
        Clip c = get_clip_by_position(position);
        if (c == null)
            return;

        Clip cn = new Clip(c.clipfile, c.type, c.name, position,
                           (position - c.start) + c.media_start, 
                           c.start + c.duration - position, false);

        c.duration = position - c.start;

        add(cn, position, false);
    }

    public void join(int64 position) {
        Command command = new ClipSplitCommand(ClipSplitCommand.Action.JOIN, this, position);
        project.do_command(command);
    }

    public void _join(int64 position) {
        assert(are_contiguous_clips(position));
        if (are_contiguous_clips(position)) {
            Clip right_clip = get_clip_by_position(position + 1);
            assert(right_clip != null);

            int right_clip_index = get_clip_index(right_clip);
            assert(right_clip_index > 0);

            int left_clip_index = right_clip_index - 1;
            Clip left_clip = get_clip(left_clip_index);
            assert(left_clip != null);
            left_clip.duration = right_clip.end - left_clip.start;
            _delete_clip(right_clip);
        }
    }

    public void trim(Clip clip, int64 delta, Gdk.WindowEdge edge) {
        Command command = new ClipTrimCommand(this, clip, delta, edge);
        project.do_command(command);
    }

    public void _trim(Clip clip, int64 delta, Gdk.WindowEdge edge) {
        clip.trim(delta, edge);
        do_clip_overwrite(clip);
    }

    public int64 previous_edit(int64 pos) {
        for (int i = clips.size - 1; i >= 0 ; --i) {
            Clip c = clips[i];
            if (c.end < pos)
                return c.end;
            if (c.start < pos)
                return c.start;
        }
        return 0;
    }

    public int64 next_edit(int64 pos) {
        foreach (Clip c in clips)
            if (c.start > pos)
                return c.start;
            else if (c.end > pos)
                return c.end;
        return get_length();
    }

    public virtual void write_attributes(FileStream f) {
        f.printf("type=\"%s\" name=\"%s\" ", name(), get_display_name());
    }

    public void save(FileStream f) {
        f.printf("    <track ");
        write_attributes(f);
        f.printf(">\n");
        for (int i = 0; i < clips.size; i++)
            clips[i].save(f, project.get_clipfile_index(clips[i].clipfile));
        f.puts("    </track>\n");
    }

    public string get_display_name() {
        return display_name;
    }

    public void set_display_name(string new_display_name) {
        if (display_name != new_display_name) {
            display_name = new_display_name;
            track_renamed(this);
        }
    }

    public void set_selected(bool is_selected) {
        if (this.is_selected != is_selected) {
            this.is_selected = is_selected;
            track_selection_changed(this);
        }
    }

    public bool get_is_selected() {
        return is_selected;
    }
}

public class AudioTrack : Track {
    double pan;
    double volume;

    int default_num_channels;
    public static const int INVALID_CHANNEL_COUNT = -1;

    public signal void parameter_changed(Parameter parameter, double new_value);
    public signal void level_changed(double level_left, double level_right);
    public signal void channel_count_changed(int channel_count);

    public AudioTrack(Project project, string display_name) {
        base(project, display_name);

        set_default_num_channels(INVALID_CHANNEL_COUNT);
        _set_pan(0);
        _set_volume(1.0);
    }

    protected override string name() { return "audio"; }

    public override MediaType media_type() {
        return MediaType.AUDIO;
    }

    public override void write_attributes(FileStream f) {
        base.write_attributes(f);
        f.printf("volume=\"%f\" panorama=\"%f\" ", get_volume(), get_pan());

        int channels;
        if (get_num_channels(out channels) &&
            channels != INVALID_CHANNEL_COUNT)
            f.printf("channels=\"%d\" ", channels);
    }

    public void set_pan(double new_value) {
        double old_value = get_pan();
        if (!float_within(new_value - old_value, 0.05)) {
            ParameterCommand parameter_command = 
                new ParameterCommand(this, Parameter.PAN, new_value, old_value);
            project.do_command(parameter_command);
        }
    }

    public void _set_pan(double new_value) {
        assert(new_value <= 1.0 && new_value >= -1.0);
        double old_value = get_pan();
        if (!float_within(old_value - new_value, 0.05)) {
            pan = new_value;
            parameter_changed(Parameter.PAN, new_value);
        }
    }

    public double get_pan() {
        return pan;
    }

    public void set_volume(double new_volume) {
        double old_volume = get_volume();
        if (!float_within(old_volume - new_volume, 0.005)) {
            ParameterCommand parameter_command =
                new ParameterCommand(this, Parameter.VOLUME, new_volume, old_volume);
            project.do_command(parameter_command);
        }
    }

    public void _set_volume(double new_volume) {
        assert(new_volume >= 0.0 && new_volume <= 10.0);
        double old_volume = get_volume();
        if (!float_within(old_volume - new_volume, 0.005)) {
            volume = new_volume;
            parameter_changed(Parameter.VOLUME, new_volume);
        }
    }

    public double get_volume() {
        return volume;
    }

    public void set_default_num_channels(int num) {
        default_num_channels = num;
    }

    public bool get_num_channels(out int num) {
        if (clips.size == 0)
            return false;

        foreach (Clip c in clips) {
            if (c.clipfile.is_online()) {
                bool can = c.clipfile.get_num_channels(out num);
                assert(can);

                return can;
            }
        }

        if (default_num_channels == INVALID_CHANNEL_COUNT)
            return false;

        num = default_num_channels;
        return true;
    }

    public override bool check(Clip clip) {
        if (!clip.clipfile.is_online()) {
            return true;
        }

        if (clips.size == 0) {
            int number_of_channels = 0;
            if (clip.clipfile.get_num_channels(out number_of_channels)) {
                channel_count_changed(number_of_channels);
            }
            return true;
        }

        bool good = false;
        int number_of_channels;
        if (clip.clipfile.get_num_channels(out number_of_channels)) {
            int track_channel_count;
            if (get_num_channels(out track_channel_count)) {
                good = track_channel_count == number_of_channels;
            }
        }

        if (!good) {
            string sub_error = number_of_channels == 1 ?
                "Mono clips cannot go on stereo tracks." :
                "Stereo clips cannot go on mono tracks.";
            error_occurred("Cannot add clip to track", sub_error);
        }
        return good;
    }

    public void on_level_changed(double level_left, double level_right) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_level_changed");
        level_changed(level_left, level_right);
    }

    public override void on_clip_updated(Clip clip) {
        if (clip.clipfile.is_online()) {
            int number_of_channels = 0;
            if (get_num_channels(out number_of_channels)) {
                channel_count_changed(number_of_channels);
            }
        }
    }
}
}