/* Copyright 2009 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 enum MediaType {
    AUDIO,
    VIDEO
}

public class Gap {
    public int64 start;
    public int64 end;

    public Gap(int64 start, int64 end) {
        this.start = start;
        this.end = end;
    }

    public bool is_empty() {
        return start >= end;
    }

    public Gap intersect(Gap g) {
        return new Gap(int64.max(start, g.start), int64.min(end, g.end));
    }
}

public class ClipFile : Object {
    public string filename;
    int64 _length;
    public int64 length {
        public get {
            if (!online) {
                warning("retrieving length while clip offline");
            }
            return _length;
        }
        
        public set {
            _length = value;
        }
    }

    bool online;

    public Gst.Caps video_caps;    // or null if no video
    public Gst.Caps audio_caps;    // or null if no audio
    public Gdk.Pixbuf thumbnail = null;

    public signal void updated();

    public ClipFile(string filename, int64 length = 0) {
        this.filename = filename;
        this.length = length;
        online = false;
    }

    public bool is_online() {
        return online;
    }

    public void set_online(bool o) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "set_online");
        online = o;
        updated();
    }

    public void set_thumbnail(Gdk.Pixbuf b) {
        // TODO: Investigate this
        // 56x56 - 62x62 icon size does not work for some reason when
        // we display the thumbnail while dragging the clip.

        thumbnail = b.scale_simple(64, 44, Gdk.InterpType.BILINEAR);
    }

    public bool has_caps_structure(MediaType m) {
        if (m == MediaType.AUDIO) {
            if (audio_caps == null || audio_caps.get_size() < 1)
                return false;
        } else if (m == MediaType.VIDEO) {
            if (video_caps == null || video_caps.get_size() < 1)
                return false;
        }
        return true;
    }

    public bool is_of_type(MediaType t) {
        if (t == MediaType.VIDEO)
            return video_caps != null;
        return audio_caps != null;
    }

    bool get_caps_structure(MediaType m, out Gst.Structure s) {
        if (!has_caps_structure(m))
            return false;
        if (m == MediaType.AUDIO) {
            s = audio_caps.get_structure(0);
        } else if (m == MediaType.VIDEO) {
            s = video_caps.get_structure(0);
        }
        return true;
    }

    public bool get_frame_rate(out Fraction rate) {
        Gst.Structure structure;
        if (!get_caps_structure(MediaType.VIDEO, out structure))
            return false;
        return structure.get_fraction("framerate", out rate.numerator, out rate.denominator);
    }

    public bool get_dimensions(out int w, out int h) {
        Gst.Structure s;

        if (!get_caps_structure(MediaType.VIDEO, out s))
            return false;

        return s.get_int("width", out w) && s.get_int("height", out h);
    }

    public bool get_sample_rate(out int rate) {
        Gst.Structure s;
        if (!get_caps_structure(MediaType.AUDIO, out s))
            return false;

        return s.get_int("rate", out rate);
    }

    public bool get_video_format(out uint32 fourcc) {
        Gst.Structure s;

        if (!get_caps_structure(MediaType.VIDEO, out s))
            return false;

        return s.get_fourcc("format", out fourcc);
    }

    public bool get_num_channels(out int channels) {
        Gst.Structure s;
        if (!get_caps_structure(MediaType.AUDIO, out s)) {
            return false;
        }

        return s.get_int("channels", out channels);
    }

    public bool get_num_channels_string(out string s) {
        int i;
        if (!get_num_channels(out i))
            return false;

        if (i == 1)
            s = "Mono";
        else if (i == 2)
            s = "Stereo";
        else if ((i % 2) == 0)
            s = "Surround %d.1".printf(i - 1);
        else
            s = "%d".printf(i);
        return true;
    }
}

public abstract class Fetcher : Object {
    protected Gst.Element filesrc;
    protected Gst.Element decodebin;
    protected Gst.Pipeline pipeline;

    public ClipFile clipfile;
    public string error_string;

    protected abstract void on_pad_added(Gst.Pad pad);
    protected abstract void on_state_change(Gst.Bus bus, Gst.Message message);

    public signal void ready(Fetcher fetcher);

    protected void do_error(string error) {
        error_string = error;
        pipeline.set_state(Gst.State.NULL);
    }

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

    protected void on_error(Gst.Bus bus, Gst.Message message) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error");
        Error error;
        string text;
        message.parse_error(out error, out text);
        do_error(text);
    }
}

public class ClipFetcher : Fetcher {  
    public signal void clipfile_online(bool online);

    public ClipFetcher(string filename) throws Error {
        clipfile = new ClipFile(filename);

        clipfile_online.connect(clipfile.set_online);

        filesrc = make_element("filesrc");
        filesrc.set("location", filename);

        decodebin = (Gst.Bin) make_element("decodebin");
        pipeline = new Gst.Pipeline("pipeline");
        pipeline.set_auto_flush_bus(false);
        if (pipeline == null)
            error("can't construct pipeline");
        pipeline.add_many(filesrc, decodebin);

        if (!filesrc.link(decodebin))
            error("can't link filesrc");
        decodebin.pad_added.connect(on_pad_added);

        Gst.Bus bus = pipeline.get_bus();

        bus.add_signal_watch();
        bus.message["state-changed"] += on_state_change;
        bus.message["error"] += on_error;
        bus.message["warning"] += on_warning;

        error_string = null;
        pipeline.set_state(Gst.State.PLAYING);
    }

    public string get_filename() { return clipfile.filename; }

    protected override void on_pad_added(Gst.Pad pad) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_added");
        Gst.Pad fake_pad;
        Gst.Element fake_sink;
        try {
            if (pad.caps.to_string().has_prefix("video")) {
                fake_sink = make_element("fakesink");
                pipeline.add(fake_sink);
                fake_pad = fake_sink.get_static_pad("sink");

                if (!fake_sink.sync_state_with_parent()) {
                    error("could not sync state with parent");
                }
            } else {
                fake_sink = make_element("fakesink");
                pipeline.add(fake_sink);
                fake_pad = fake_sink.get_static_pad("sink");

                if (!fake_sink.sync_state_with_parent()) {
                    error("could not sync state with parent");
                }
            }
            pad.link(fake_pad);
        }
        catch (Error e) {
        }
    }

    Gst.Pad? get_pad(string prefix) {
        foreach(Gst.Pad pad in decodebin.pads) {
            string caps = pad.caps.to_string();
            if (caps.has_prefix(prefix)) {
                return pad;
            }
        }
        return null;
    }

    protected override void on_state_change(Gst.Bus bus, Gst.Message message) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_state_change");
        if (message.src != pipeline)
            return;

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

        message.parse_state_changed(out old_state, out new_state, out pending);
        if (new_state == old_state) 
            return;

        if (new_state == Gst.State.PLAYING) {
            Gst.Pad? pad = get_pad("video");
            if (pad != null) {
                clipfile.video_caps = pad.caps;
            }

            pad = get_pad("audio");
            if (pad != null) {
                clipfile.audio_caps = pad.caps;
            }

            Gst.Format format = Gst.Format.TIME;
            int64 length;
            if (!pipeline.query_duration(ref format, out length) ||
                    format != Gst.Format.TIME) {
                do_error("Can't fetch length");
                return;
            }
            clipfile.length = length;

            clipfile_online(true);
            pipeline.set_state(Gst.State.NULL);
        } else if (new_state == Gst.State.NULL) {
            ready(this);
        }
    }
}

public class ThumbnailFetcher : Fetcher {
    ThumbnailSink thumbnail_sink;
    Gst.Element colorspace;
    int64 seek_position;
    bool done_seek;
    bool have_thumbnail;

    public ThumbnailFetcher(ClipFile f, int64 time) throws Error {
        clipfile = f;
        seek_position = time;

        SingleDecodeBin single_bin = new SingleDecodeBin (
                                        Gst.Caps.from_string ("video/x-raw-rgb; video/x-raw-yuv"),
                                        "singledecoder", f.filename);

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

        thumbnail_sink = new ThumbnailSink();
        thumbnail_sink.have_thumbnail.connect(on_have_thumbnail);

        colorspace = make_element("ffmpegcolorspace");

        pipeline.add_many(single_bin, thumbnail_sink, colorspace);

        single_bin.pad_added.connect(on_pad_added);

        colorspace.link(thumbnail_sink);

        Gst.Bus bus = pipeline.get_bus();

        bus.add_signal_watch();
        bus.message["state-changed"] += on_state_change;
        bus.message["error"] += on_error;
        bus.message["warning"] += on_warning;

        have_thumbnail = false;
        done_seek = false;
        pipeline.set_state(Gst.State.PAUSED);
    }

    void on_have_thumbnail(Gdk.Pixbuf buf) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_have_thumbnail");
        if (done_seek) {
            have_thumbnail = true;
            clipfile.set_thumbnail(buf);
        }
    }

    protected override void on_pad_added(Gst.Pad pad) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_pad_added");
        Gst.Caps c = pad.get_caps();

        if (c.to_string().has_prefix("video")) {
            pad.link(colorspace.get_static_pad("sink"));
        }
    }

    protected override void on_state_change(Gst.Bus bus, Gst.Message message) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_state_change");
        if (message.src != pipeline)
            return;

        Gst.State new_state;
        Gst.State old_state;
        Gst.State pending_state;

        message.parse_state_changed (out old_state, out new_state, out pending_state);
        if (new_state == old_state &&
            new_state != Gst.State.PAUSED)
            return;

        if (new_state == Gst.State.PAUSED) {
            if (!done_seek) {
                done_seek = true;
                pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, seek_position);
            } else {
                if (have_thumbnail)
                    pipeline.set_state(Gst.State.NULL);
            }
        } else if (new_state == Gst.State.NULL) {
            ready(this);
        }
    }
}

public class Clip : Object {
    public ClipFile clipfile;
    public MediaType type;
    // TODO: If a clip is being recorded, we don't want to set duration in the MediaClip file.
    // Address when handling multiple track recording.  This is an ugly hack.
    public bool is_recording;
    public string name;
    int64 _start;
    public int64 start { 
        get {
            return _start;
        }

        set {
            _start = value;
            if (connected) {
                start_changed(_start);
            }
            moved(this);
        }
    }

    int64 _media_start;
    public int64 media_start { 
        get {
            return _media_start;
        }
    }

    int64 _duration;
    public int64 duration {
        get {
            return _duration;
        }

        set {
            if (value < 0) {
                // saturating the duration
                value = 0;
            }

            if (!is_recording) {
                if (value + _media_start > clipfile.length) {
                    // saturating the duration
                    value = clipfile.length - media_start;
                }
            }

            _duration = value;
            if (connected) {
                duration_changed(_duration);
            }
            moved(this);
        }
    }

    bool connected;

    public int64 end {
        get { return start + duration; }
    }

    public signal void moved(Clip clip);
    public signal void updated(Clip clip);
    public signal void media_start_changed(int64 media_start);
    public signal void duration_changed(int64 duration);
    public signal void start_changed(int64 start);
    public signal void removed(Clip clip);

    public Clip(ClipFile clipfile, MediaType t, string name,
                int64 start, int64 media_start, int64 duration, bool is_recording) {
        this.is_recording = is_recording;
        this.clipfile = clipfile;
        this.type = t;
        this.name = name;
        this.connected = clipfile.is_online();
        this.set_media_start_duration(media_start, duration);
        this.start = start;
        clipfile.updated.connect(on_clipfile_updated);
    }

    public void gnonlin_connect() { connected = true; }
    public void gnonlin_disconnect() { connected = false; }

    void on_clipfile_updated(ClipFile f) {
        emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clipfile_updated");
        if (f.is_online()) {
            if (!connected) {
                connected = true;
                // TODO: Assigning to oneself has the side-effect of firing signals. 
                // fire signals directly.  Make certain that loading a file still works
                // properly in this case.
                set_media_start_duration(media_start, duration);

                start = start;
            }
        } else {
            if (connected) {
                connected = false;
            }
        }
        updated(this);
    }

    public bool overlap_pos(int64 start, int64 length) {
        return start < this.start + this.duration &&
                this.start < start + length;
    }

    public int64 snap(Clip other, int64 pad) {
        if (time_in_range(start, other.start, pad)) {
            return other.start;
        } else if (time_in_range(start, other.end, pad)) {
            return other.end;
        } else if (time_in_range(end, other.start, pad)) {
            return other.start - duration;
        } else if (time_in_range(end, other.end, pad)) {
            return other.end - duration;
        }
        return start;
    }

    public bool snap_coord(out int64 s, int64 span) {
        if (time_in_range(s, start, span)) {
            s = start;
            return true;
        } else if (time_in_range(s, end, span)) {
            s = end;
            return true;
        }
        return false;
    }

    public Clip copy() {
        return new Clip(clipfile, type, name, start, media_start, duration, false);
    }

    public bool is_trimmed() {
        if (!clipfile.is_online()) 
            return false;
        return duration != clipfile.length;
    }

    public void trim(int64 delta, Gdk.WindowEdge edge) {
        switch (edge) {
            case Gdk.WindowEdge.WEST:
                if (media_start + delta < 0) {
                    delta = -media_start;
                }

                if (duration - delta < 0) {
                    delta = duration;
                }

                start += delta;
                set_media_start_duration(media_start + delta, duration - delta);
                break;
            case Gdk.WindowEdge.EAST:
                duration += delta;
                break;
        }
    }

    public void set_media_start_duration(int64 media_start, int64 duration) {
        if (media_start < 0) {
            media_start = 0;
        }

        if (duration < 0) {
            duration = 0;
        }

        if (clipfile.is_online() && media_start + duration > clipfile.length) {
            // We are saturating the value
            media_start = clipfile.length - duration;
        }

        _media_start = media_start;
        _duration = duration;

        if (connected) {
            media_start_changed(_media_start);
            duration_changed(_duration);
        }

        moved(this);
    }

    public void save(FileStream f, int id) {
        f.printf(
            "      <clip id=\"%d\" name=\"%s\" start=\"%" + int64.FORMAT + "\" " +
                    "media-start=\"%" + int64.FORMAT + "\" duration=\"%" + int64.FORMAT + "\"/>\n",
                    id, name, start, media_start, duration);
    }
}

public class FetcherCompletion {
    public FetcherCompletion() {
    }

    public virtual void complete(Fetcher fetcher) {
    }
}
}