module flow-node-inventory {
    namespace "urn:opendaylight:flow:inventory";
    prefix flownode;

    import yang-ext {prefix ext; revision-date "2013-07-09";}
    import ietf-inet-types {prefix inet; revision-date "2010-09-24";}
    import ietf-yang-types {prefix yang; revision-date "2010-09-24";}
    import opendaylight-port-types {prefix port;revision-date "2013-09-25";}
    import opendaylight-inventory {prefix inv;revision-date "2013-08-19";}
    import opendaylight-table-types {prefix table;revision-date "2013-10-26";}
    import opendaylight-flow-types {prefix flow;revision-date "2013-10-26";}
    import opendaylight-group-types {prefix group;revision-date "2013-10-18";}
    import opendaylight-meter-types {prefix meter;revision-date "2013-09-18";}
    
    revision "2013-08-19" {
        description "Flow Capable Node extensions to the Inventory model";
    }
    
    identity feature-capability {
    }
    
    identity flow-feature-capability-flow-stats {
        description "Flow statistics"; 
        base feature-capability;      
    }
    
    identity flow-feature-capability-table-stats {
        description "Table statistics";
        base feature-capability;        
    }
    
    identity flow-feature-capability-port-stats {
        description "Port statistics";
        base feature-capability;        
    }
    
    identity flow-feature-capability-stp {
        description "802.1d spanning tree";
        base feature-capability;        
    }
    
    identity flow-feature-capability-reserved {
        description "Reserved, must be zero";
        base feature-capability;        
    }
    
    identity flow-feature-capability-ip-reasm {
        description "Can reassemble IP fragments";
        base feature-capability;        
    }
    
    identity flow-feature-capability-queue-stats {
        description "Queue statistics";
        base feature-capability;        
    }
    
    identity flow-feature-capability-arp-match-ip {
        description "Match IP addresses in ARP pkts";
        base feature-capability;        
    }
    
    identity flow-feature-capability-group-stats {
        description "Group statistics";
        base feature-capability;        
    }
    
    identity flow-feature-capability-port-blocked {
        description "Switch will block looping ports";
        base feature-capability;        
    }
    
    grouping feature {
        leaf support-state {
            type inv:support-type;
        }
    }

    grouping queue {
         leaf queue-id {
            type uint32;
            description "id for the specific queue";
            mandatory true; 
        }
        container properties {
            leaf minimum-rate {
                type uint32;
            }
            leaf maximum-rate{
                type uint32;
            }
        }
    }

    typedef flow-id {
        type inet:uri;
    }

    grouping tables {
        list table {
            key "id"; 
    
            leaf id {
                    type uint8;
            }            
    
            uses table:table-features;
    
            list flow {
                key "id"; 
    
                leaf id {
                    type flow-id;
                }           
    
                uses flow:flow;
            }
        }
    }
    
    grouping meters {
        list meter {
            key "meter-id";
            uses meter:meter;
        }
    }
    
    
    grouping flow-node {

        leaf manufacturer {
            type string;
        }
        leaf hardware {
            type string;
        }
        leaf software {
            type string;
        }
        leaf serial-number {
            type string;
        }
        leaf description {
            type string;
        }

        uses tables;
        uses group:groups;
        uses meters;
        // TODO: ports
        
        container supported-match-types {
            list match-type {
                uses feature;
                leaf match {
                    type string; // FIXME: Add identity
                }
                
            }
        }
        
        container supported-instructions {
            list instruction-type {
                uses feature;
                leaf instruction {
                    type string; // FIXME: Add identity
                }
            }
        }

        container supported-actions {
            list action-type {
                uses feature;

                leaf action {
                    type string; // FIXME: Add identity
                }
            }
        }
        
        container switch-features {
            
            leaf max_buffers {
                type uint32;
            }
            
            leaf max_tables {
                type uint8;
            }
            
            leaf-list capabilities {
                type identityref {
                    base feature-capability;
                }
            }
            
        }
    }
    
    grouping flow-node-connector {

        uses port:flow-capable-port;
    }

    augment "/inv:nodes/inv:node" {
        ext:augment-identifier "flow-capable-node";
        uses flow-node;
    }

    augment "/inv:nodes/inv:node/inv:node-connector" {
        ext:augment-identifier "flow-capable-node-connector";
        uses flow-node-connector;
    }

    augment "/inv:node-updated" {
        ext:augment-identifier "flow-capable-node-updated";
        uses flow-node;
    }

    augment "/inv:node-updated/inv:node-connector" {
        //ext:identical-augment "flow-capable-node-connector";
        ext:augment-identifier "flow-capable-node-connector-update-fields";
        uses flow-node-connector;
    }
    
    augment "/inv:node-connector-updated" {
        ext:augment-identifier "flow-capable-node-connector-updated";
        uses flow-node-connector;
    }

}