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

extern const string _VERSION;

namespace Model {
public class MediaLoaderHandler : LoaderHandler {
    protected weak Project the_project;
    protected Track current_track;

    Gee.ArrayList<ClipFetcher> clipfetchers = new Gee.ArrayList<ClipFetcher>();
    int num_clipfiles_complete;

    public MediaLoaderHandler(Project the_project) {
        this.the_project = the_project;
        current_track = null;
    }

    public override bool commit_marina(string[] attr_names, string[] attr_values) {
        int number_of_attributes = attr_names.length;
        if (number_of_attributes != 1 ||
            attr_names[0] != "version") {
            load_error("Missing version information");
            return false;
        }

        if (the_project.get_file_version() < attr_values[0].to_int()) {
            load_error("Version mismatch! (File Version: %d, App Version: %d)".printf(
                the_project.get_file_version(), attr_values[0].to_int()));
            return false;
        }

        num_clipfiles_complete = 0;
        return true;
    }

    public override bool commit_library(string[] attr_names, string[] attr_values) {
        // We return true since framerate is an optional parameter
        if (attr_names.length != 1)
            return true;

        if (attr_names[0] != "framerate") {
            load_error("Missing framerate tag");
            return false;
        }

        string[] arr = attr_values[0].split("/");
        if (arr.length != 2) {
            load_error("Invalid framerate attribute");
            return false;
        }

        the_project.set_default_framerate(Fraction(arr[0].to_int(), arr[1].to_int()));
        return true;
    }

    public override bool commit_track(string[] attr_names, string[] attr_values) {
        assert(current_track == null);

        int number_of_attributes = attr_names.length;
        string? name = null;
        string? type = null;
        for (int i = 0; i < number_of_attributes; ++i) {
            switch(attr_names[i]) {
                case "type":
                    type = attr_values[i];
                    break;
                case "name":
                    name = attr_values[i];
                    break;
                default:
                    break;
            }
        }

        if (name == null) {
            load_error("Missing track name");
            return false;
        }

        if (type == null) {
            load_error("Missing track type");
            return false;
        }

        if (type == "audio") {
            AudioTrack audio_track = new AudioTrack(the_project, name);
            current_track = audio_track;
            the_project.add_track(current_track);

            for (int i = 0; i < number_of_attributes; ++i) {
                switch(attr_names[i]) {
                    case "panorama":
                        audio_track._set_pan(attr_values[i].to_double());
                        break;
                    case "volume":
                        audio_track._set_volume(attr_values[i].to_double());
                        break;
                    case "channels":
                        audio_track.set_default_num_channels(attr_values[i].to_int());
                        break;
                    default:
                        break;
                }
            }
            return true;
        } else if (type == "video") {
            current_track = new VideoTrack(the_project);
            the_project.add_track(current_track);
        }

        return base.commit_track(attr_names, attr_values);
    }

    public override void leave_track() {
        assert(current_track != null);
        current_track = null;
    }

    public override bool commit_clip(string[] attr_names, string[] attr_values) {
        assert(current_track != null);

        int number_of_attributes = attr_names.length;
        int id = -1;
        string? clip_name = null;
        int64 start = -1;
        int64 media_start = -1;
        int64 duration = -1;
        for (int i = 0; i < number_of_attributes; i++) {
        switch (attr_names[i]) {
            case "id":
                id = attr_values[i].to_int();
                break;
            case "name":
                clip_name = attr_values[i];
                break;
            case "start":
                start = attr_values[i].to_int64();
                break;
            case "media-start":
                media_start = attr_values[i].to_int64();
                break;
            case "duration":
                duration = attr_values[i].to_int64();
                break;
            default:
                // TODO: we need a way to deal with orphaned attributes, for now, reject the file
                load_error("Unknown attribute %s".printf(attr_names[i]));
                return false;
            }
        }

        if (id == -1) {
            load_error("missing clip id");
            return false;
        }

        if (clip_name == null) {
            load_error("missing clip_name");
            return false;
        }

        if (start == -1) {
            load_error("missing start time");
            return false;
        }

        if (media_start == -1) {
            load_error("missing media_start");
            return false;
        }

        if (duration == -1) {
            load_error("missing duration");
            return false;
        }

        if (id >= clipfetchers.size) {
            load_error("clip file id %s was not loaded".printf(clip_name));
            return false;
        }

        Clip clip = new Clip(clipfetchers[id].clipfile, current_track.media_type(), clip_name, 
            start, media_start, duration, false);
        current_track.add(clip, start, false);
        return true;
    }

    void fetcher_ready(Fetcher f) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "fetcher_ready");
        if (f.error_string != null) {
            load_error("Could not load %s.".printf(f.clipfile.filename));
            warning("Could not load %s: %s", f.clipfile.filename, f.error_string);
        }
        the_project.add_clipfile(f.clipfile);
        num_clipfiles_complete++;
        if (num_clipfiles_complete == clipfetchers.size) {
            complete();
        }
    }

    public override bool commit_clipfile(string[] attr_names, string[] attr_values) {
        string filename = null;
        int id = -1;

        for (int i = 0; i < attr_names.length; i++) {
            if (attr_names[i] == "filename") {
                filename = attr_values[i];
            } else if (attr_names[i] == "id") {
                id = attr_values[i].to_int();
            }
        }

        if (filename == null) {
            load_error("Invalid clipfile filename");
            return false;
        }

        if (id < 0) {
            load_error("Invalid clipfile id");
            return false;
        }

        try {
            ClipFetcher fetcher = new ClipFetcher(filename);
            fetcher.ready.connect(fetcher_ready);
            clipfetchers.insert(id, fetcher);
        } catch (Error e) {
            load_error(e.message);
            return false;
        }
        return true;
    }

    public override bool commit_tempo_entry(string[] attr_names, string[] attr_values) {
        if (attr_names[0] != "tempo") {
            load_error("Invalid attribute on tempo entry");
            return false;
        }

        the_project._set_bpm(attr_values[0].to_int());
        return true;
    }

    public override bool commit_time_signature_entry(string[] attr_names, string[] attr_values) {
        if (attr_names[0] != "signature") {
            load_error("Invalid attribute on time signature");
            return false;
        }

        the_project._set_time_signature(Fraction.from_string(attr_values[0]));
        return true;
    }

    public override bool commit_click(string[] attr_names, string[] attr_values) {
        for (int i = 0; i < attr_names.length; ++i) {
            switch (attr_names[i]) {
                case "on_play":
                    the_project.click_during_play = attr_values[i] == "true";
                break;
                case "on_record":
                    the_project.click_during_record = attr_values[i] == "true";
                break;
                case "volume":
                    the_project.click_volume = attr_values[i].to_double();
                break;
                default:
                    load_error("unknown attribute for click '%s'".printf(attr_names[i]));
                    return false;
            }
        }
        return true;
    }

    public override bool commit_library_preference(string[] attr_names, string[] attr_values) {
        for (int i = 0; i < attr_names.length; ++i) {
            switch (attr_names[i]) {
                case "width":
                    the_project.library_width = attr_values[i].to_int();
                break;
                case "visible":
                    the_project.library_visible = attr_values[i] == "true";
                break;
                default:
                    load_error("unknown attribute for library '%s'".printf(attr_names[i]));
                    return false;
            }
        }
        return true;
    }

    public override void leave_library() {
        if (clipfetchers.size == 0)
            complete();
    }
}

public abstract class Project : TempoInformation, Object {
    public const string FILLMORE_FILE_EXTENSION = "fill";
    public const string FILLMORE_FILE_FILTER = "*." + FILLMORE_FILE_EXTENSION;   
    public const string LOMBARD_FILE_EXTENSION = "lom";
    public const string LOMBARD_FILE_FILTER = "*." + LOMBARD_FILE_EXTENSION;

    const string license = """
%s is free software; you can redistribute it and/or modify it under the 
terms of the GNU Lesser General Public License as published by the Free 
Software Foundation; either version 2.1 of the License, or (at your option) 
any later version.

%s 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 Lesser General Public License for 
more details.

You should have received a copy of the GNU Lesser General Public License 
along with %s; if not, write to the Free Software Foundation, Inc., 
51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
""";

    public const string[] authors = { 
        "Robert Powell <rob@yorba.org>",
        "Adam Dingle <adam@yorba.org>",
        "Andrew O'Mahony <andrew.omahony@att.net>",
        "Dru Moore <usr@dru-id.co.uk>",
        null
    };

    public Gee.ArrayList<Track> tracks = new Gee.ArrayList<Track>();
    public Gee.ArrayList<Track> inactive_tracks = new Gee.ArrayList<Track>();
    Gee.HashSet<ClipFetcher> pending = new Gee.HashSet<ClipFetcher>();
    Gee.ArrayList<ThumbnailFetcher> pending_thumbs = new Gee.ArrayList<ThumbnailFetcher>();
    protected Gee.ArrayList<ClipFile> clipfiles = new Gee.ArrayList<ClipFile>();
    // TODO: media_engine is a member of project only temporarily.  It will be
    // less work to move it to fillmore/lombard once we have a transport class.
    public View.MediaEngine media_engine;

    protected string project_file;  // may be null if project has not yet been saved
    public ProjectLoader loader;

    FetcherCompletion fetcher_completion;
    public UndoManager undo_manager;
    public LibraryImporter importer;

    public Fraction default_framerate;
    int tempo = 120;
    Fraction time_signature = Fraction(4, 4);
    public bool click_during_play = false;
    public bool click_during_record = true;
    public double click_volume = 0.8;
    public bool library_visible = true;
    public int library_width = 600;
    public bool snap_to_clip;

    /* TODO:
     * This can't be const since the Vala compiler (0.7.7) crashes if we try to make it a const.
     * I've filed a bug with the Vala bugzilla for this:
     * https://bugzilla.gnome.org/show_bug.cgi?id=598204
     */    
    public static Fraction INVALID_FRAME_RATE = Fraction(-1, 1);

    public signal void playstate_changed(PlayState playstate);

    public signal void name_changed(string? project_file);
    public signal void load_error(string error);
    public virtual signal void load_complete() {
    }

    public signal void closed();

    public signal void track_added(Track track);
    public signal void track_removed(Track track);
    public signal void error_occurred(string major_message, string? minor_message);

    public signal void clipfile_added(ClipFile c);
    public signal void clipfile_removed(ClipFile clip_file);
    public signal void cleared();

    public abstract TimeCode get_clip_time(ClipFile f);

    public Project(string? filename, bool include_video) throws Error {
        undo_manager = new UndoManager();
        project_file = filename;

        media_engine = new View.MediaEngine(this, include_video);
        track_added.connect(media_engine.on_track_added);
        media_engine.playstate_changed.connect(on_playstate_changed);
        media_engine.error_occurred.connect(on_error_occurred);

        set_default_framerate(INVALID_FRAME_RATE);
    }

    public void on_playstate_changed() {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_playstate_changed");
        switch (media_engine.get_play_state()) {
            case PlayState.STOPPED:
                ClearTrackMeters();
                break;
            case PlayState.CLOSED:
                closed();
                break;
        }
        playstate_changed(media_engine.get_play_state());
    }

    public virtual string? get_project_file() {
        return project_file;
    }

    public ClipFile? get_clipfile(int index) {
        if (index < 0 ||
            index >= clipfiles.size)
            return null;
        return clipfiles[index];
    }

    public int get_clipfile_index(ClipFile find) {
        int i = 0;
        foreach (ClipFile f in clipfiles) {
            if (f == find)
                return i;
            i++;
        }
        return -1;
    }

    public Track? track_from_clip(Clip clip) {
        foreach (Track track in tracks) {
            foreach (Clip match in track.clips) {
                if (match == clip) {
                    return track;
                }
            }
        }
        return null;
    }

    public void print_graph(Gst.Bin bin, string file_name) {
        Gst.debug_bin_to_dot_file_with_ts(bin, Gst.DebugGraphDetails.ALL, file_name);
    }

    public int64 get_length() {
        int64 max = 0;
        foreach (Track track in tracks) {
            max = int64.max(max, track.get_length());
        }
        return max;
    }

    public int64 snap_clip(Clip c, int64 span) {
        foreach (Track track in tracks) {
            int64 new_start = track.snap_clip(c, span);
            if (new_start != c.start) {
                return new_start;
            }
        }
        return c.start;
    }

    public void snap_coord(out int64 coord, int64 span) {
        foreach (Track track in tracks) {
            if (track.snap_coord(out coord, span)) {
                break;
            }
        }
    }

    Gap get_gap_intersection(Gap gap) {
        Gap intersection = gap;

        foreach (Track track in tracks) {
            intersection = intersection.intersect(track.find_first_gap(intersection.start));
        }

        return intersection;
    }

    public bool can_delete_gap(Gap gap) {
        Gap intersection = get_gap_intersection(gap);
        return !intersection.is_empty();
    }

    public void delete_gap(Gap gap) {
        Gap intersection = get_gap_intersection(gap);
        assert(!intersection.is_empty());

        foreach (Track track in tracks) {
            track.delete_gap(intersection);
        }
    }

    protected virtual void do_append(Track track, ClipFile clipfile, string name, 
        int64 insert_time) {
        switch(track.media_type()) {
            case MediaType.AUDIO:
                if (clipfile.audio_caps == null) {
                    return;
                }
                break;
            case MediaType.VIDEO:
                if (clipfile.video_caps == null) {
                    return;
                }
            break;
        }

        Clip clip = new Clip(clipfile, track.media_type(), name, 0, 0, clipfile.length, false);
        track.append_at_time(clip, insert_time, true);
    }

    public void append(Track track, ClipFile clipfile) {
        string name = isolate_filename(clipfile.filename);
        int64 insert_time = 0;

        foreach (Track temp_track in tracks) {
            insert_time = int64.max(insert_time, temp_track.get_length());
        }
        do_append(track, clipfile, name, insert_time);
    }

    public void add(Track track, ClipFile clipfile, int64 time) {
        string name = isolate_filename(clipfile.filename);
        do_append(track, clipfile, name, time);
    }

    public void on_clip_removed(Track t, Clip clip) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_removed");
        reseek();
    }

    public void split_at_playhead() {
        string description = "Split At Playhead";
        undo_manager.start_transaction(description);
        foreach (Track track in tracks) {
            if (track.get_clip_by_position(transport_get_position()) != null) {
                track.split_at(transport_get_position());
            }
        }
        undo_manager.end_transaction(description);
    }

    public bool can_trim(out bool left) {
        Clip first_clip = null;

        // When trimming multiple clips, we allow trimming left only if both clips already start
        // at the same position, and trimming right only if both clips already end at the same
        // position.

        int64 start = 0;
        int64 end = 0;
        bool start_same = true;
        bool end_same = true;
        foreach (Track track in tracks) {
            Clip clip = track.get_clip_by_position(transport_get_position());
            if (first_clip != null && clip != null) {
                start_same = start_same && start == clip.start;
                end_same = end_same && end == clip.end;
            } else if (clip != null) {
                first_clip = clip;
                start = first_clip.start;
                end = first_clip.end;
            }
        }

        if (first_clip == null) {
            return false;
        }

        if (start_same && !end_same) {
            left = true;
            return true;
        }

        if (!start_same && end_same) {
            left = false;
            return true;
        }

        // which half of the clip are we closer to?
        left = (transport_get_position() - first_clip.start < first_clip.duration / 2);
        return true;
    }

    public void trim_to_playhead() {
        bool left;
        if (!can_trim(out left)) {
            return;
        }
        string description = "Trim To Playhead";
        Clip first_clip = null;
        undo_manager.start_transaction(description);
        foreach (Track track in tracks) {
            Clip clip = track.get_clip_by_position(transport_get_position());
            if (clip != null) {
                int64 delta;
                if (left) {
                    delta = transport_get_position() - clip.start;
                } else {
                    delta = transport_get_position() - clip.end;
                }
                track.trim(clip, delta, left ? Gdk.WindowEdge.WEST : Gdk.WindowEdge.EAST);
            }
        }
        undo_manager.end_transaction(description);

        if (left && first_clip != null) {
            transport_go(first_clip.start);
        }
    }

    public void transport_go(int64 position) {
        media_engine.go(position);
    }

    public bool transport_is_playing() {
        return media_engine.playing;
    }

    public bool transport_is_recording() {
        return media_engine.get_play_state() == PlayState.PRE_RECORD ||
               media_engine.get_play_state() == PlayState.RECORDING;
    }

    public bool playhead_on_clip() {
        foreach (Track track in tracks) {
            if (track.get_clip_by_position(transport_get_position()) != null) {
                return true;
            }
        }
        return false;
    }

    public bool playhead_on_contiguous_clip() {
        foreach (Track track in tracks) {
            if (track.are_contiguous_clips(transport_get_position())) {
                return true;
            }
        }
        return false;
    }

    public bool is_duplicate_track_name(Track? track, string new_name) {
        assert(new_name != "");
        foreach (Track this_track in tracks) {
            if (track != this_track) {
                if (this_track.get_display_name() == new_name) {
                    return true;
                }
            }
        }
        
        foreach (Track this_track in inactive_tracks) {
            if (track != this_track) {
                if (this_track.get_display_name() == new_name) {
                    return true;
                }
            }
        }
        return false;
    }

    public virtual void add_track(Track track) {
        track.clip_removed.connect(on_clip_removed);
        track.error_occurred.connect(on_error_occurred);
        tracks.add(track);
        track_added(track);
    }
    public virtual void insert_track(int index, Track track) {
        if (0 > index) index = 0;
        if (tracks.size <= index) {
          add_track(track);
        }
        else {
          track.clip_removed.connect(on_clip_removed);
          track.error_occurred.connect(on_error_occurred);
          tracks.insert(index, track);
          track_added(track);
        }
    }

    public void add_inactive_track(Track track) {
        track.hide();
        inactive_tracks.add(track);
    }

    public void remove_track(Track track) {
        media_engine.pipeline.set_state(Gst.State.NULL);
        track.track_removed(track);
        tracks.remove(track);
        track_removed(track);
    }
    
    public void remove_track_at(int index) {
        remove_track(tracks.get(index));
    }

    public void add_clipfile(ClipFile clipfile) {
        Model.Command command = new Model.AddClipCommand(this, clipfile);
        do_command(command);
    }

    public void _add_clipfile(ClipFile clipfile) throws Error {
        clipfiles.add(clipfile);
        if (clipfile.is_online() && clipfile.is_of_type(MediaType.VIDEO)) {
            ThumbnailFetcher fetcher = new ThumbnailFetcher(clipfile, 0);
            fetcher.ready.connect(on_thumbnail_ready);
            pending_thumbs.add(fetcher);
        } else {
            clipfile_added(clipfile);
        }
    }

    void on_thumbnail_ready(Fetcher f) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_thumbnail_ready");
        clipfile_added(f.clipfile);
        pending_thumbs.remove(f as ThumbnailFetcher);
    }

    public bool clipfile_on_track(string filename) {
        ClipFile cf = find_clipfile(filename);

        foreach (Track t in tracks) {
            foreach (Clip c in t.clips) {
                if (c.clipfile == cf)
                    return true;
            }
        }

        foreach (Track t in inactive_tracks) {
            foreach (Clip c in t.clips) {
                if (c.clipfile == cf)
                    return true;
            }
        }

        return false;
    }

    void delete_clipfile_from_tracks(ClipFile cf) {
        foreach (Track t in tracks) {
            for (int i = 0; i < t.clips.size; i++) {
                if (t.clips[i].clipfile == cf) {
                    t.delete_clip(t.clips[i]);
                    i --;
                }
            }
        }

        foreach (Track t in inactive_tracks) {
            for (int i = 0; i < t.clips.size; i++) {
                if (t.clips[i].clipfile == cf) {
                    t.delete_clip(t.clips[i]);
                    i --;
                }
            }
        }
    }

    public void _remove_clipfile(ClipFile cf) {
        clipfiles.remove(cf);
        clipfile_removed(cf);
    }

    public void remove_clipfile(string filename) {
        ClipFile cf = find_clipfile(filename);
        if (cf != null) {
            string description = "Delete From Library";
            undo_manager.start_transaction(description);

            delete_clipfile_from_tracks(cf);

            Command clipfile_delete = new ClipFileDeleteCommand(this, cf);
            do_command(clipfile_delete);

            undo_manager.end_transaction(description);
        }
    }
    
    public ClipFile? find_clipfile(string filename) {
        foreach (ClipFile cf in clipfiles)
            if (cf.filename == filename)
                return cf;
        return null;
    }

    public void reseek() { transport_go(transport_get_position()); }

    public void go_start() { transport_go(0); }

    public void go_end() { transport_go(get_length()); }

    public void go_previous() {
        int64 start_pos = transport_get_position();

        // If we're currently playing, we jump to the previous clip if we're within the first
        // second of the current clip.
        if (transport_is_playing())
            start_pos -= 1 * Gst.SECOND;

        int64 new_position = 0;
        foreach (Track track in tracks) {
            new_position = int64.max(new_position, track.previous_edit(start_pos));
        }
        transport_go(new_position);
    }

    // Move to the next clip boundary after the current transport position.
    public void go_next() {
        int64 start_pos = transport_get_position();
        int64 new_position = get_length();
        foreach (Track track in tracks) {
            if (track.get_length() > start_pos) {
                new_position = int64.min(new_position, track.next_edit(start_pos));
            }
        }
        transport_go(new_position);
    }

    public int64 transport_get_position() {
        return media_engine.position;
    }

    public void set_name(string? filename) {
        if (filename != null) {
            this.project_file = filename;
        }
        name_changed(filename);
    }

    public void set_default_framerate(Fraction rate) {
        default_framerate = rate;
    }

    public string get_file_display_name() {
        string filename = get_project_file();
        if (filename == null) {
            return "Unsaved Project - %s".printf(get_app_name());
        }
        else {
            string dir = Path.get_dirname(filename);
            string name = Path.get_basename(filename);
            string home_path = GLib.Environment.get_home_dir();

            if (dir == ".")
                dir = GLib.Environment.get_current_dir();

            if (dir.has_prefix(home_path))
                dir = "~" + dir.substring(home_path.length);
            return "%s (%s) - %s".printf(name, dir, get_app_name());
        }
    }

    public void clear() {
        media_engine.set_gst_state(Gst.State.NULL);

        foreach (Track track in tracks) {
            track.delete_all_clips();
            track.track_removed(track);
            track_removed(track);
        }

        tracks.clear();
        
        clipfiles.clear();
        set_name(null);
        cleared();
    }

    public bool can_export() {
        if (media_engine.get_play_state() != PlayState.STOPPED) {
            return false;
        }
        foreach (Track track in tracks) {
            if (track.get_length() > 0) {
                return true;
            }
        }
        return false;
    }

    public void on_load_started(string filename) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_started");
        project_file = filename;
    }

    void on_load_error(string error) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_error");
        load_error(error);
    }

    void on_load_complete() {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_complete");
        undo_manager.reset();
        set_name(project_file);
        load_complete(); 
    }

    // Load a project file.  The load is asynchronous: it may continue after this method returns.
    // Any load error will be reported via the load_error signal, which may run either while this
    // method executes or afterward.
    public virtual void load(string? fname) {
        emit(this, Facility.LOADING, Level.INFO, "loading project");
        clear();
        set_name(null);
        if (fname == null) {
            return;
        }

        loader = new ProjectLoader(new MediaLoaderHandler(this), fname);

        loader.load_started.connect(on_load_started);
        loader.load_error.connect(on_load_error);
        loader.load_complete.connect(on_load_complete);
        loader.load_complete.connect(media_engine.on_load_complete);
        media_engine.set_play_state(PlayState.LOADING);
        media_engine.pipeline.set_state(Gst.State.NULL);
        loader.load();
    }

    public void on_error_occurred(string major_error, string? minor_error) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error_occurred");
        error_occurred(major_error, minor_error);
    }

    public int get_file_version() {
        return 4;
    }

    public void save_library(FileStream f) {
        f.printf("  <library");

        Fraction r = default_framerate;

        foreach (Track t in tracks) {
            if (t.media_type () == MediaType.VIDEO) {
                VideoTrack video_track = t as VideoTrack;
                if (video_track.get_framerate(out r))
                    break;
            }
        }
        if (!r.equal(INVALID_FRAME_RATE))
            f.printf(" framerate=\"%d/%d\"", r.numerator, 
                                             r.denominator);
        f.printf(">\n");

        for (int i = 0; i < clipfiles.size; i++) {
            f.printf("    <clipfile filename=\"%s\" id=\"%d\"/>\n", clipfiles[i].filename, i);
        }

        f.printf("  </library>\n");
    }

    public virtual void save(string? filename) {
        if (filename != null) {
            set_name(filename);
        }

        FileStream f = FileStream.open(project_file, "w");
        if (f == null) {
            error_occurred("Could not save project",
                "%s: %s".printf(project_file, GLib.strerror(GLib.errno)));
            return;
        }
        f.printf("<marina version=\"%d\">\n", get_file_version());

        save_library(f);

        f.printf("  <tracks>\n");
        foreach (Track track in tracks) {
            track.save(f);
        }
        
        foreach (Track track in inactive_tracks) {
            track.save(f);
        }
        f.printf("  </tracks>\n");
        f.printf("  <preferences>\n");
        f.printf("    <click on_play=\"%s\" on_record=\"%s\" volume=\"%lf\"/>\n", 
            click_during_play ? "true" : "false",
            click_during_record ? "true" : "false",
            click_volume);
        f.printf("    <library width=\"%d\" visible=\"%s\" />\n",
            library_width, library_visible ? "true" : "false");
        f.printf("  </preferences>\n");
        f.printf("  <maps>\n");
        f.printf("    <tempo>\n");
        f.printf("      <entry tempo=\"%d\" />\n", tempo);
        f.printf("    </tempo>\n");
        f.printf("    <time_signature>\n");
        f.printf("      <entry signature=\"%s\" />\n", time_signature.to_string());
        f.printf("    </time_signature>\n");
        f.printf("  </maps>\n");

        f.printf("</marina>\n");
        f.flush();

        // TODO: clean up responsibility between dirty and undo
        undo_manager.mark_clean();
    }

    public void close() {
        media_engine.close();
    }

    public void on_importer_clip_complete(ClipFetcher fetcher) {
        if (fetcher.error_string != null) {
            error_occurred("Error importing clip", fetcher.error_string);
        } else {
            fetcher_completion.complete(fetcher);
        }
    }

    public void create_clip_fetcher(FetcherCompletion fetcher_completion, string filename) 
            throws Error {
        ClipFetcher fetcher = new ClipFetcher(filename);
        this.fetcher_completion = fetcher_completion;
        fetcher.ready.connect(on_fetcher_ready);
        pending.add(fetcher);
    }

    // TODO: We should be using Library importer rather than this mechanism for fillmore
    void on_fetcher_ready(Fetcher fetcher) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_fetcher_ready");
        pending.remove(fetcher as ClipFetcher);
        if (fetcher.error_string != null) {
            emit(this, Facility.DEVELOPER_WARNINGS, Level.INFO, fetcher.error_string);
            error_occurred("Error retrieving clip", fetcher.error_string);
        } else {
            if (get_clipfile_index(fetcher.clipfile) == -1) {
                add_clipfile(fetcher.clipfile);
            }
            fetcher_completion.complete(fetcher);
        }
    }

    public bool is_project_extension(string filename) {
        string extension = get_file_extension(filename);
        return extension == LOMBARD_FILE_EXTENSION || extension == FILLMORE_FILE_EXTENSION;
    }

    public void do_command(Command the_command) {
        undo_manager.do_command(the_command);
    }

    public void undo() {
        undo_manager.undo();
    }

    void ClearTrackMeters() {
        foreach (Track track in tracks) {
            AudioTrack audio_track = track as AudioTrack;
            if (audio_track != null) {
                audio_track.level_changed(-100, -100);
            }
        }
    }

    public void create_clip_importer(Model.Track? track, bool timeline_add, 
            int64 time_to_add, bool both_tracks, Gtk.Window? progress_window_parent, int number) {
        if (timeline_add) {
            assert(track != null);
            importer = new Model.TimelineImporter(track, this, time_to_add, both_tracks);
        } else {
            importer = new Model.LibraryImporter(this);
        }
        if (progress_window_parent != null) {
            new MultiFileProgress(progress_window_parent, number, "Import", 
                importer.importer);
        }

    }

    public string get_version() {
        return _VERSION;
    }

    public abstract string get_app_name();

    public string get_license() {
        return license.printf(get_app_name(), get_app_name(), get_app_name());
    }

    public void set_time_signature(Fraction time_signature) {
        TimeSignatureCommand command = new TimeSignatureCommand(this, time_signature);
        undo_manager.do_command(command);
    }

    public void _set_time_signature(Fraction time_signature) {
        this.time_signature = time_signature;
        time_signature_changed(time_signature);
    }

    public Fraction get_time_signature() {
        return time_signature;
    }

    public void set_bpm(int bpm) {
        BpmCommand command = new BpmCommand(this, bpm);
        undo_manager.do_command(command);
    }

    public void _set_bpm(int bpm) {
        this.tempo = bpm;
        bpm_changed(bpm);
    }

    public int get_bpm() {
        return tempo;
    }

    public string get_audio_path() {
        string path = get_path();
        return path == null ? null : Path.build_filename(path, "audio files");
    }

    string get_path() {
        return project_file == null ? null : Path.get_dirname(project_file);
    }

    public VideoTrack? find_video_track() {
        foreach (Track track in tracks) {
            if (track is VideoTrack) {
                return track as VideoTrack;
            }
        }
        return null;
    }

    public AudioTrack? find_audio_track() {
        foreach (Track track in tracks) {
            if (track is AudioTrack) {
                return track as AudioTrack;
            }
        }
        return null;
    }
}
}