/* 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 class ClipImporter : MultiFileProgressInterface, Object {
    enum ImportState {
        FETCHING,
        IMPORTING,
        CANCELLED
    }

    string import_directory;

    ImportState import_state;
    bool import_done;
    bool all_done;
    ClipFetcher our_fetcher;

    Gst.Pad video_pad;
    Gst.Pad audio_pad;
    
    Gst.Pipeline pipeline = null;
    Gst.Element filesink;
    Gst.Element video_convert;
    Gst.Element audio_convert;
    Gst.Element mux;

    Gst.Bin video_decoder;
    Gst.Bin audio_decoder;

    int current_file_importing = 0;

    int64 current_time;
    int64 total_time;
    int64 previous_time;

    Gee.ArrayList<string> filenames = new Gee.ArrayList<string>();
    Gee.ArrayList<ClipFetcher> queued_fetchers = new Gee.ArrayList<ClipFetcher>();
    Gee.ArrayList<string> queued_filenames = new Gee.ArrayList<string>();
    Gee.ArrayList<string> no_import_formats = new Gee.ArrayList<string>();

    public signal void clip_complete(ClipFile f);
    public signal void importing_started(int num_clips);
    public signal void error_occurred(string error);

    public ClipImporter() {
        import_directory = GLib.Environment.get_home_dir();
        import_directory += "/.lombard_fillmore_import/";

        GLib.DirUtils.create(import_directory, 0777);

        no_import_formats.add("YUY2");
        no_import_formats.add("Y41B");

        import_state = ImportState.FETCHING;
    }

    public void add_filename(string filename) {
        filenames.add(filename);
    }

    bool on_timer_callback() {
        int64 time;
        Gst.Format format = Gst.Format.TIME;

        if (all_done) 
            return false;

        if (pipeline.query_position(ref format, out time) &&
            format == Gst.Format.TIME) {
            if (time > previous_time)
                current_time += time - previous_time;
            previous_time = time;
            if (current_time >= total_time) {
                fraction_updated(1.0);
                return false;
            } else
                fraction_updated(current_time / (double)total_time);    
        }
        return true;
    }

    void start_import() {
        import_state = ImportState.IMPORTING;
        current_file_importing = 0;
        importing_started(queued_fetchers.size);
        Timeout.add(50, on_timer_callback);
    }

    void cancel() {
        all_done = true;
        import_state = ImportState.CANCELLED;
        if (pipeline != null) {
            pipeline.set_state(Gst.State.NULL);
        }
    }

    public void start() throws Error {
        process_curr_file();
    }

    void process_curr_file() throws Error {
        if (import_state == ImportState.FETCHING) {
            if (current_file_importing == filenames.size) {
                if (queued_fetchers.size == 0)
                    done();
                else
                    start_import();
            } else {
                emit(this, Facility.IMPORT, Level.VERBOSE, 
                    "fetching %s".printf(filenames[current_file_importing]));
                our_fetcher = new Model.ClipFetcher(filenames[current_file_importing]);
                our_fetcher.ready.connect(on_fetcher_ready);
            }
        }

        if (import_state == ImportState.IMPORTING) {
            if (current_file_importing == queued_fetchers.size) {
                fraction_updated(1.0);
                all_done = true;
            } else
                do_import(queued_fetchers[current_file_importing]);
        }
    }

    // TODO: Rework this
    void complete() {
        all_done = true;
    }

    void do_import_complete() throws Error{
        if (import_state == ImportState.IMPORTING) {
            our_fetcher.clipfile.filename = append_extension(
                                                   queued_filenames[current_file_importing], "mov");
            clip_complete(our_fetcher.clipfile);
        } else
            total_time += our_fetcher.clipfile.length;

        current_file_importing++;

        if (current_file_importing <= filenames.size)
            process_curr_file();
        else
            warning ("do_import_complete: current_file_importing out of bounds! %d %d".printf(
                                                          current_file_importing, filenames.size));
    }

    bool need_to_import(Fetcher f) {
        //for now, use the clip as is
        return false;
        /*
        if (f.clipfile.is_of_type(MediaType.VIDEO)) {
            uint32 format;
            if (f.clipfile.get_video_format(out format)) {
                foreach (string s in no_import_formats) {
                    if (format == *(uint32*)s) {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
        */
    }

    void on_fetcher_ready(Fetcher f) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_fetcher_ready");
        try {
            if (f.error_string != null) {
                error_occurred(f.error_string);
                do_import_complete();
                return;
            }

            if (need_to_import(f)) {
                string checksum;
                if (md5_checksum_on_file(f.clipfile.filename, out checksum)) {
                    string base_filename = import_directory + isolate_filename(f.clipfile.filename);

                    int index = 0;
                    string new_filename = base_filename;
                    while (true) {
                        string existing_checksum;
                        if (get_file_md5_checksum(new_filename, out existing_checksum)) {
                            if (checksum == existing_checksum) {
                                // Re-fetch this clip to get the correct caps
                                filenames[current_file_importing] =
                                                            append_extension(new_filename, "mov");
                                current_file_importing--;
                                total_time -= f.clipfile.length;
                                break;
                            }
                            index++;
                            new_filename = base_filename + index.to_string();
                        } else {
                            // Truly need to import
                            save_file_md5_checksum(new_filename, checksum);
                            queued_filenames.add(new_filename);
                            queued_fetchers.add(f as ClipFetcher);
                            break;
                        }
                    }
                } else
                    error("Cannot get md5 checksum for file %s!", f.clipfile.filename);
            } else {
                clip_complete(f.clipfile);
            }
            do_import_complete();
        } catch (Error e) {
            error_occurred(e.message);
        }
    }

    void do_import(ClipFetcher f) throws Error {
        file_updated(f.clipfile.filename, current_file_importing);
        previous_time = 0;

        our_fetcher = f;
        import_done = false;
        pipeline = new Gst.Pipeline("pipeline");
        pipeline.set_auto_flush_bus(false);

        Gst.Bus bus = pipeline.get_bus();
        bus.add_signal_watch();

        bus.message["state-changed"] += on_state_changed;
        bus.message["eos"] += on_eos;
        bus.message["error"] += on_error;
        bus.message["warning"] += on_warning;

        mux = make_element("qtmux");

        filesink = make_element("filesink");
        filesink.set("location", append_extension(queued_filenames[current_file_importing], "mov"));

        pipeline.add_many(mux, filesink);

        if (f.clipfile.is_of_type(MediaType.VIDEO)) {
            video_convert = make_element("ffmpegcolorspace");
            pipeline.add(video_convert);

            video_decoder = new SingleDecodeBin(Gst.Caps.from_string(
                                                               "video/x-raw-yuv"),
                                                               "videodecodebin", 
                                                               f.clipfile.filename);
            video_decoder.pad_added.connect(on_pad_added);

            pipeline.add(video_decoder);

            if (!video_convert.link(mux))
                error("do_import: Cannot link video converter to mux!");
        }
        if (f.clipfile.is_of_type(MediaType.AUDIO)) {
            audio_convert = make_element("audioconvert");
            pipeline.add(audio_convert);

            // setup for importing h.264 and other int flavors.  change to audio/x-raw-float
            // if you need to import ogg and other float flavors.  see bug 2055
            audio_decoder = new SingleDecodeBin(
                Gst.Caps.from_string("audio/x-raw-int"),
                                                    "audiodecodebin", f.clipfile.filename);
            audio_decoder.pad_added.connect(on_pad_added);

            pipeline.add(audio_decoder);

            if (!audio_convert.link(mux))
                error("do_import: Cannot link audio convert to mux!");
        }

        if (!mux.link(filesink))
            error("do_import: Cannot link mux to filesink!");

        emit(this, Facility.IMPORT, Level.VERBOSE, 
            "Starting import to %s...".printf(queued_filenames[current_file_importing]));
        pipeline.set_state(Gst.State.PLAYING);
    }

    void on_pad_added(Gst.Pad p) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_added");

        string str = p.caps.to_string();
        Gst.Pad sink = null;

        if (str.has_prefix("video")) {
            video_pad = p;
            sink = video_convert.get_compatible_pad(p, p.caps);
        } else if (str.has_prefix("audio")) {
            audio_pad = p;
            sink = audio_convert.get_compatible_pad(p, p.caps);
        } else {
            //error_occurred here gives a segfault
            warning("Unrecognized prefix %s".printf(str));
            return;
        }

        if (p.link(sink) != Gst.PadLinkReturn.OK) {
            error("Cannot link pad in importer!");
        }
    }

    void on_error(Gst.Bus bus, Gst.Message message) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error");
        Error e;
        string text;
        message.parse_error(out e, out text);
        warning("%s\n", text);
        error_occurred(text);
    }

    void on_warning(Gst.Bus bus, Gst.Message message) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_warning");
        Error e;
        string text;
        message.parse_warning(out e, out text);
        warning("%s", text);
    }

    void on_state_changed(Gst.Bus b, Gst.Message m) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_state_changed");
        if (m.src != pipeline) 
            return;

        Gst.State old_state;
        Gst.State new_state;
        Gst.State pending;

        m.parse_state_changed (out old_state, out new_state, out pending);

        if (old_state == new_state) 
            return;

        emit(this, Facility.IMPORT, Level.VERBOSE,
            "Import State in %s".printf(new_state.to_string()));
        if (new_state == Gst.State.PAUSED) {
            if (!import_done) {
                if (video_pad != null) {
                    our_fetcher.clipfile.video_caps = video_pad.caps;
                }
                if (audio_pad != null) {
                    our_fetcher.clipfile.audio_caps = audio_pad.caps;
                }
                emit(this, Facility.IMPORT, Level.VERBOSE,
                    "Got clipfile info for: %s".printf(our_fetcher.clipfile.filename));
            }
        } else if (new_state == Gst.State.NULL) {
            if (import_state == ImportState.CANCELLED) {
                GLib.FileUtils.remove(append_extension(queued_filenames[current_file_importing], 
                                                                                            "mov"));
                GLib.FileUtils.remove(append_extension(queued_filenames[current_file_importing], 
                                                                                            "md5"));
            } else {
                if (import_done) 
                    try {
                        do_import_complete();
                    } catch (Error e) {
                        error_occurred(e.message);
                    }
            }
        }
    }

    void on_eos() {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_eos");
        import_done = true;
        pipeline.set_state(Gst.State.NULL);
    }
}

public class LibraryImporter : Object {
    protected Project project;
    public ClipImporter importer;

    public signal void started(ClipImporter i, int num);
    
    public LibraryImporter(Project p) {
        project = p;
        
        importer = new ClipImporter();
        importer.clip_complete.connect(on_clip_complete);
        importer.error_occurred.connect(on_error_occurred);
        importer.importing_started.connect(on_importer_started);
    }

    void on_importer_started(ClipImporter i, int num) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_importer_started");
        started(i, num);
    }

    void on_error_occurred(string error) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error_occurred");
        emit(this, Facility.DEVELOPER_WARNINGS, Level.INFO, error);
        project.error_occurred("Error importing", "An error occurred importing this file.");
    }

    protected virtual void append_existing_clipfile(ClipFile f) {

    }

    protected virtual void on_clip_complete(ClipFile f) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_complete");
        ClipFile cf = project.find_clipfile(f.filename);
        if (cf == null) {
            project.add_clipfile(f);
        }
    }

    public void add_file(string filename) throws Error {
        ClipFile cf = project.find_clipfile(filename);

        if (cf != null)
            append_existing_clipfile(cf);
        else
            importer.add_filename(filename);
    }

    public void start() throws Error {
        importer.start();
    }
}

public class TimelineImporter : LibraryImporter {
    Track track;
    int64 time_to_add;
    bool both_tracks;

    public TimelineImporter(Track track, Project p, int64 time_to_add, bool both_tracks) {
        base(p);
        this.track = track;
        this.time_to_add = time_to_add;
        this.both_tracks = both_tracks;
    }

    void add_to_both(ClipFile clip_file) {
        if (both_tracks) {
            Track other_track;
            if (track is Model.VideoTrack) {
                other_track = project.find_audio_track();
            } else {
                other_track = project.find_video_track();
            }
            if (other_track != null) {
                project.add(other_track, clip_file, time_to_add);
            }
        }
    }

    protected override void append_existing_clipfile(ClipFile f) {
        project.undo_manager.start_transaction("Create Clip");
        project.add(track, f, time_to_add);
        add_to_both(f);
        project.undo_manager.end_transaction("Create Clip");
    }

    protected override void on_clip_complete(ClipFile f) {
        project.undo_manager.start_transaction("Create Clip");
        base.on_clip_complete(f);
        project.add(track, f, time_to_add);
        add_to_both(f);
        project.undo_manager.end_transaction("Create Clip");
    }
}
}