/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 *  @software  : lib-yaml    <https://git.pluie.org/pluie/lib-yaml>
 *  @version   : 0.4
 *  @date      : 2018
 *  @licence   : GPLv3.0     <http://www.gnu.org/licenses/>
 *  @author    : a-Sansara   <[dev]at[pluie]dot[org]>
 *  @copyright : pluie.org   <http://www.pluie.org/>
 * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 *  This file is part of lib-yaml.
 *  
 *  lib-yaml is free software (free as in speech) : you can redistribute it
 *  and/or modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation, either version 3 of the License,
 *  or (at your option) any later version.
 *  
 *  lib-yaml 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 General Public License for
 *  more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with lib-yaml.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 */

using GLib;
using Gee;
using Pluie;

/**
 * a class dealing with a sequence of yaml events and composing the Yaml Node Graph
 */
public class Pluie.Yaml.Processor
{
    /**
     * indicates if processing is sucess
     */
    public bool                       done;

    /**
     * indicates if new node has been created
     */
    bool                              change;

    /**
     * indicates if begon a flow sequence
     */
    bool                              beginFlowSeq;

    /**
     * current anchor id
     */
    string?                           idAnchor;

    /**
     * current key
     */
    string?                           ckey;

    /**
     * Events list
     */
    public Gee.ArrayList<Yaml.Event>  events           { get; internal set; }

    /**
     * Anchor map
     */
    Gee.HashMap<string, Yaml.Node>    anchors          { get; internal set; }

    /**
     * Error event
     */
    Yaml.Event?                       event            { get; internal set; }

    /**
     * Error event
     */
    public Yaml.Event?                error_event      { get; internal set; }

    /**
     * the root Yaml.Node
     */
    public Yaml.Node                  root;

    /**
     * current previous Yaml.Node
     */
    Yaml.Node?                        prev_node;

    /**
     * current parent Yaml.Node
     */
    Yaml.Node?                        parent_node;

    /**
     * current Yaml.Node
     */
    Yaml.Node                         node;

    /**
     * Yaml.Event Iterator
     */
    Gee.Iterator<Yaml.Event>          iterator;

    /**
     *
     */
    public Processor ()
    {
        this.events  = new Gee.ArrayList<Yaml.Event>();
        this.anchors = new Gee.HashMap<string, Yaml.Node>();
    }

    /**
     * display the list of events generated via yaml.c
     */
    public void read ()
    {
        of.action ("Reading events");
        foreach (Yaml.Event event in this.events) {
            int len = 24 - event.evtype.infos ().length;
            stdout.printf ("    [ %s"+@" %$(len)s "+", %d, %s", event.evtype.infos (), " ", event.line, event.style != null ? event.style.to_string () : "0");
            if (event.data != null && event.data.size > 0) {
                stdout.printf (", {");
                var it = event.data.map_iterator ();
                string sep;
                for (var has_next = it.next (); has_next; has_next = it.next ()) {
                    sep = it.has_next () ? ", " : "";
                    stdout.printf ("%s: %s%s", it.get_key (), it.get_value (), sep);
                }
                stdout.printf (" }");
            }
            of.echo ("]");
        }
    }

    /**
     * processing the events list and generate the corresponding Yaml Nodes
     */
    public bool run ()
    {
        if (Yaml.Scanner.DEBUG) {
            this.read ();
            of.action ("Processing events");
        }
        this.reset ();
        for (var has_next = this.iterator.next (); has_next; has_next = this.iterator.next ()) {
            this.event = this.iterator.get ();
            if (this.event.evtype.is_error ()) {
                this.on_error ();
                break;
            }
            if (this.event.evtype.is_mapping_end () || this.event.evtype.is_sequence_end ()) {
                this.on_block_end ();
                continue;
            }
            if (this.event.evtype.is_entry ()) {
                this.on_entry ();
            }
            if (this.beginFlowSeq && this.event.evtype.is_scalar ()) {
                this.on_scalar (true);
                this.beginFlowSeq = false;
            }
            if (this.event.evtype.is_key () && (this.event = this.get_value_key_event ()) != null) {
                this.on_key ();
            }
            if (this.event.evtype.is_value () && (this.event = this.get_value_event ()) != null) {
                this.on_value ();
                if (this.event.evtype.is_mapping_start ()) {
                    this.on_mapping_start ();
                }
                else if (this.event.evtype.is_sequence_start ()) {
                    this.on_sequence_start ();
                }
                this.add_anchor_if_needed ();
                this.ckey = null;
            }
            this.on_update ();
        }
        this.done = error_event == null && this.root != null;
        return done;
    }

    /**
     *
     */
    private void reset ()
    {
        this.root         = new Yaml.Mapping (null, "PluieYamlRoot");
        this.root.ntype   = Yaml.NODE_TYPE.ROOT;
        this.prev_node    = this.root; 
        this.parent_node  = this.root;
        this.iterator     = this.events.iterator ();
        this.change       = false;
        this.ckey         = null;
        this.idAnchor     = null;
        this.beginFlowSeq = false;
    }

    /**
     * retriew the next Yaml Event
     */
    private Yaml.Event? next_event ()
    {
        Yaml.Event? evt = null;
        if (this.iterator.has_next () && this.iterator.next ()) {
            evt = this.iterator.get ();
        }
        return evt;
    }

    /**
     * retriew the next Yaml Value Event closest to Key Event
     */
    private Yaml.Event? get_value_key_event ()
    {
        Yaml.Event? evt = null;
        var e = this.iterator.get ();
        if (e != null && e.evtype.is_key ()) {
            evt = this.next_event ();
        }
        return evt;
    }

    /**
     * retriew the next Yaml Value Event
     */
    private Yaml.Event? get_value_event ()
    {
        Yaml.Event? evt = null;
        var e = this.iterator.get ();
        if (e != null && e.evtype.is_value ()) {
            evt = this.next_event ();
        }
        return evt;
    }

    /**
     *
     */
    private void on_error ()
    {
        this.error_event = this.event;
    }

    /**
     *
     */
    private void on_block_end ()
    {
        this.parent_node = this.prev_node.parent != null && this.prev_node.parent != this.root 
            ? this.prev_node.parent.parent 
            : this.root;
        this.prev_node   = this.parent_node;
    }

    /**
     *
     */
    private void on_entry ()
    {
        this.event = this.next_event();
        if (this.event.evtype.is_mapping_start ()) {
            this.on_mapping_start (true);
        }
        else if (this.event.evtype.is_scalar ()) {
            this.on_scalar (true);
        }
    }

    /**
     *
     */
    private void on_key ()
    {
        this.ckey = this.event.data["data"];
    }

    /**
     *
     */
    private void on_value ()
    {
        if (this.event.evtype.is_scalar ()) {
            this.on_scalar ();
        }
        else if (this.event.evtype.is_anchor ()) {
            this.on_anchor ();
        }
        else if (this.event.evtype.is_alias ()) {
            this.on_alias ();
        }
    }

    /**
     *
     */
    private void on_scalar (bool entry = false)
    {
        if (!entry) {
            if (this.ckey != null) {
                this.node   = new Yaml.Mapping.with_scalar (this.parent_node, this.ckey, this.event.data["data"]);
                this.change = true;
            }
        }
        else {
            this.node   = new Yaml.Scalar (this.parent_node, this.event.data["data"]);
            this.change = true;
        }
    }

    /**
     *
     */
    private void on_anchor ()
    {
        this.idAnchor = this.event.data["id"];
        this.event    = this.next_event ();
    }

    /**
     *
     */
    private void on_alias ()
    {
        this.idAnchor      = this.event.data["id"];
        Yaml.Node? refnode = this.anchors.get(this.idAnchor);
        if (refnode != null) {
            this.node = refnode.clone_node (this.ckey);
            this.parent_node.add (this.node);
            this.prev_node = this.node;
        }
    }

    /**
     *
     */
    private void on_sequence_start ()
    {
        this.node         = new Yaml.Sequence (this.parent_node, this.ckey);
        this.change       = true;
        this.beginFlowSeq = true;
    }

    /**
     *
     */
    private void on_mapping_start (bool entry = false)
    {
        if (entry) {
            this.create_mapping (entry);
            this.ckey   = null;
        }
        else this.create_mapping ();
    }

    /**
     *
     */
    private void create_mapping (bool entry = false)
    {
        if (entry) {
            this.ckey = "_%d".printf(this.parent_node.count());
        }
        this.node   = new Yaml.Mapping (this.parent_node, this.ckey);
        this.change = true;
    }

    /**
     *
     */
    private void add_anchor_if_needed ()
    {
        if (this.idAnchor != null) {
            if (this.node != null) {
                this.anchors.set(this.idAnchor, this.node);
            }
            this.idAnchor = null;
        }
    }

    /**
     *
     */
    private void on_update ()
    {
        if (this.change) {
            if (this.node.ntype.is_collection () && (this.node.empty() || (!this.node.first().ntype.is_scalar ()))) {
                this.parent_node = this.node;
            }
            else {
                this.parent_node = this.node.parent;
            }
            this.prev_node = this.node;
            this.node      = null;
            this.change    = false;
        }
    }

}