module opendaylight-match-types {
    namespace "urn:opendaylight:model:match:types";
    prefix "match";

    import ietf-inet-types {prefix inet;}
    import ietf-yang-types {prefix yang;}
    import opendaylight-l2-types {prefix l2t;}

    revision "2013-08-19" {
        description "Initial revision of flow service";
    }

    grouping "mac-address-filter" {
        leaf address {
            mandatory true;
            type yang:mac-address;
        }
        leaf mask {
            type binary;
        }
    }

     /** Match Groupings **/
    grouping "ethernet-match-fields" {
        container ethernet-source {
            description "Ethernet source address.";
            presence "Match field is active and set";
            uses mac-address-filter;
        }
        container ethernet-destination {
            description "Ethernet destination address.";
            presence "Match field is active and set";
            uses mac-address-filter;
        }
        container ethernet-type {
            description "Ethernet frame type.";
            presence "Match field is active and set";
            
            leaf type {
                mandatory true;
                type l2t:ether-type; // Needs to define that as general model
            }
            leaf mask {
                type binary;
            }
        }
    }

    grouping "vlan-match-fields" {
        container vlan-id {
            description "VLAN id.";
            presence "Match field is active and set";
            
            leaf vlan-id {
                mandatory true;
                type l2t:vlan-id; 
            }
            leaf mask {
                type binary;
            }
        }
        leaf vlan-pcp {
            description "VLAN priority.";
            type l2t:vlan-pcp;
        }
    }

    grouping "ip-match-fields" {
        leaf ip-protocol {
                description "IP protocol.";
                type uint8; 
        }

        leaf ip-dscp {
            description "IP DSCP (6 bits in ToS field).";
            type inet:dscp; 
        }
        leaf ip-ecn {
            description "IP ECN (2 bits in ToS field).";
            type uint8; 
        }
    }

    grouping "ipv4-match-fields" {
        leaf ipv4-source {
            description "IPv4 source address.";
            type inet:ipv4-prefix;
        }
        leaf ipv4-destination {
            description "IPv4 destination address.";
            type inet:ipv4-prefix;
        }
    }

    grouping "ipv6-match-fields" {
        leaf ipv6-source {
            description "IPv6 source address.";
            type inet:ipv6-prefix;
        }
        leaf ipv6-destination {
            description "IPv6 destination address.";
            type inet:ipv6-prefix;
        }
    }

    grouping "udp-match-fields" {
        leaf udp-source-port {
            description "UDP source port.";
            type inet:port-number;
        }
        leaf udp-destination-port {
            description "UDP destination port.";
                type inet:port-number;
        }
    }

    grouping "tcp-match-fields" {
        leaf tcp-source-port {
            description "TCP source port.";
            type inet:port-number;
        }
        leaf tcp-destination-port {
            description "TCP destination port.";
            type inet:port-number;
        }
    }

    grouping "sctp-match-fields" {
        leaf sctp-source-port {
            description "SCTP source port.";
            type inet:port-number;
        }
        leaf sctp-destination-port {
            description "SCTP destination port.";
            type inet:port-number;
        }
    }

    grouping "icmpv4-match-fields" {
        leaf icmpv4-type {
        description "ICMP type.";
            type uint8; // Define ICMP Type
        }
        description "ICMP code.";
        leaf icmpv4-code {
            type uint8; // Define ICMP Code
        }
    }

    grouping "arp-match-fields" {
        leaf arp-source-transport-address {
            description "ARP source IPv4 address.";
            type inet:ipv4-prefix;
        }
    
        leaf arp-target-transport-address {
            description "ARP target IPv4 address.";
            type inet:ipv4-prefix;
        }
        container arp-source-hardware-address {
            description "ARP source hardware address.";
            presence "Match field is active and set";
        uses mac-address-filter;
        }
        container arp-target-hardware-address {
            description "ARP target hardware address.";
            presence "Match field is active and set";
        uses mac-address-filter;
        }
    }

    grouping action {
        choice action {
            case output-action {
                leaf-list output-node-connector {
                    type string;
                }
            }

            case controller-action {
                leaf max-length {
                    type uint16 {
                        range "0..65294";
                    }
                }
            }

            case set-queue-action {
                leaf queue {
                    type string; // TODO: define queues
                }
            }

            case pop-mpls-action {
                container pop-mpls {
                    leaf ethernet-type {
                        type uint16; // TODO: define ethertype type
                    }
                }
            }

            case set-mpls-ttl-action {
                leaf mpls-ttl {
                    type uint8;
                }
            }

            case set-nw-ttl-action {
                leaf nw-ttl {
                    type uint8;
                }
            }

            case push-pbb-action {

            }

            case push-mpls-action {

            }

            case push-vlan-action {

            }
        }
    }


    grouping match {
        container "ethernet-match" {
            uses "ethernet-match-fields";
        }
        container "vlan-match" {
            uses "vlan-match-fields";
        }
        container "ip-match" {
            uses "ip-match-fields";
        }
        
        choice layer-3-match {
            case "ipv4-match" {
                uses "ipv4-match-fields";
            }
            case "ipv6-match" {
                uses "ipv6-match-fields";
            }
            case "arp-match" {
                uses "arp-match-fields";
            }
        }
        
        choice layer-4-match {
            case "udp-match" {
                uses "udp-match-fields";
            }
            case "tcp-match" {
                uses "tcp-match-fields";
            }
            case "sctp-match" {
                uses "sctp-match-fields";
            }
        }
        container "icmpv4-match" {
            uses "icmpv4-match-fields";
        }
    }
}