--------------------------------------------------------------------------------
--  Copyright (c) 2011-2012 Sierra Wireless.
--  All rights reserved. This program and the accompanying materials
--  are made available under the terms of the Eclipse Public License v1.0
--  which accompanies this distribution, and is available at
--  http://www.eclipse.org/legal/epl-v10.html
--
--  Contributors:
--       Simon BERNARD <sbernard@sierrawireless.com>
--           - initial API and implementation and initial documentation
--------------------------------------------------------------------------------
local M = {}

--------------------------------------------------------------------------------
-- API MODEL
--------------------------------------------------------------------------------

function M._file()
  local file = {
    -- FIELDS
    tag              = "file",
    name             = nil,    -- string
    shortdescription = "",    -- string
    description      = "",    -- string
    types            = {},     -- map from typename to type
    globalvars       = {},     -- map from varname to item
    returns          = {},     -- list of return

    -- FUNCTIONS
    addtype =  function (self,type)
      self.types[type.name] = type
      type.parent = self
    end,

    mergetype =  function (self,newtype,erase,erasesourcerangefield)
      local currenttype = self.types[newtype.name]
      if currenttype then
        -- merge recordtypedef
        if currenttype.tag =="recordtypedef" and newtype.tag == "recordtypedef" then
          -- merge fields
          for fieldname ,field in pairs( newtype.fields) do
            local currentfield = currenttype.fields[fieldname]
            if erase or not currentfield then
              currenttype:addfield(field)
            elseif erasesourcerangefield then
              if field.sourcerange.min and field.sourcerange.max then
                currentfield.sourcerange.min = field.sourcerange.min
                currentfield.sourcerange.max = field.sourcerange.max
              end
            end
          end

          -- merge descriptions and source ranges
          if erase then
            if newtype.description or newtype.description == ""  then currenttype.description = newtype.description end
            if newtype.shortdescription or newtype.shortdescription == ""  then currenttype.shortdescription = newtype.shortdescription end
            if newtype.sourcerange.min and newtype.sourcerange.max then
              currenttype.sourcerange.min = newtype.sourcerange.min
              currenttype.sourcerange.max = newtype.sourcerange.max
            end
          end
          -- merge functiontypedef
        elseif currenttype.tag == "functiontypedef" and newtype.tag == "functiontypedef" then
          -- merge params
          for i, param1 in ipairs(newtype.params) do
            local missing = true
            for j, param2 in ipairs(currenttype.params) do
              if param1.name == param2.name then
                missing = false
                break
              end
            end
            if missing then
              table.insert(currenttype.params,param1)
            end
          end

          -- merge descriptions and source ranges
          if erase then
            if newtype.description or newtype.description == "" then currenttype.description = newtype.description end
            if newtype.shortdescription or newtype.shortdescription == ""  then currenttype.shortdescription = newtype.shortdescription end
            if newtype.sourcerange.min and newtype.sourcerange.max then
              currenttype.sourcerange.min = newtype.sourcerange.min
              currenttype.sourcerange.max = newtype.sourcerange.max
            end
          end
        end
      else
        self:addtype(newtype)
      end
    end,

    addglobalvar =  function (self,item)
      self.globalvars[item.name] = item
      item.parent = self
    end,

    moduletyperef = function (self)
      if self and self.returns[1] and self.returns[1].types[1] then
        local typeref = self.returns[1].types[1]
        return typeref
      end
    end
  }
  return file
end

function M._recordtypedef(name)
  local recordtype = {
    -- FIELDS
    tag                  = "recordtypedef",
    name                 = name,    -- string (mandatory)
    shortdescription     = "",      -- string
    description          = "",      -- string
    fields               = {},      -- map from fieldname to field
    sourcerange          = {min=0,max=0},
    supertype            = nil,     -- supertype of the type def (inheritance), should be a recordtypedef ref
    defaultkeytyperef    = nil,     -- the default typeref of key
    defaultvaluetyperef  = nil,     -- the default typeref of value
    structurekind        = nil,     -- kind of structure of the type: could be nil, "map" or "list"
    structuredescription = nil,     -- description of the structure
    call                 = nil,     -- typeref to the function use as __call on the type.
    -- FUNCTIONS
    addfield = function (self,field)
      self.fields[field.name] = field
      field.parent = self
    end,

    getcalldef = function( self)
      if self.call and self.call.tag == 'internaltyperef' then
        if self.parent and self.parent.tag == 'file' then
          local file = self.parent
          return file.types[self.call.typename]
        end
      end
    end
  }
  return recordtype
end

function M._functiontypedef(name)
  return {
    tag              = "functiontypedef",
    name             = name,              -- string (mandatory)
    shortdescription = "",               -- string
    description      = "",               -- string
    params           = {},                -- list of parameter
    returns          = {}                 -- list of return
  }
end

function M._parameter(name)
  return {
    tag         = "parameter",
    name        = name, -- string (mandatory)
    description = "",   -- string
    type        = nil   -- typeref (external or internal or primitive typeref)
  }
end

function M._item(name)
  return {
    -- FIELDS
    tag              = "item",
    name             = name,   -- string (mandatory)
    shortdescription = "",     -- string
    description      = "",     -- string
    type             = nil,    -- typeref (external or internal or primitive typeref)
    occurrences      = {},     -- list of identifier (see internalmodel)
    sourcerange      = {min=0, max=0},

    -- This is A TRICK
    -- This value is ALWAYS nil, except for internal purposes (short references).
    external         = nil,

    -- FUNCTIONS
    addoccurence = function (self,occ)
      table.insert(self.occurrences,occ)
      occ.definition = self
    end,

    resolvetype = function (self,file)
      if self and self.type then
        if self.type.tag =="internaltyperef" then
          -- if file is not given try to retrieve it.
          if not file then
            if self.parent and self.parent.tag == 'recordtypedef' then
              file = self.parent.parent
            elseif self.parent.tag == 'file' then
              file = self.parent
            end
          end
          if file then return file.types[self.type.typename] end
        elseif self.type.tag =="inlinetyperef" then
          return self.type.def
        end
      end
    end
  }
end

function M._externaltypref(modulename, typename)
  return {
    tag        = "externaltyperef",
    modulename = modulename,        -- string
    typename   =  typename          -- string
  }
end

function M._internaltyperef(typename)
  return {
    tag      = "internaltyperef",
    typename =  typename          -- string
  }
end

function M._primitivetyperef(typename)
  return {
    tag      = "primitivetyperef",
    typename =  typename           -- string
  }
end

function M._moduletyperef(modulename,returnposition)
  return {
    tag            = "moduletyperef",
    modulename     = modulename,      -- string
    returnposition = returnposition   -- number
  }
end

function M._exprtyperef(expression,returnposition)
  return {
    tag            = "exprtyperef",
    expression     =  expression,   -- expression (see internal model)
    returnposition = returnposition -- number
  }
end

function M._inlinetyperef(definition)
  return {
    tag            = "inlinetyperef",
    def            =  definition,   -- expression (see internal model)

  }
end

function M._return(description)
  return {
    tag         = "return",
    description =  description or "", -- string
    types       = {}                  -- list of typref (external or internal or primitive typeref)
  }
end
return M