# For loading all potential module dependencies of a module

import scrib_constants as constants
import scrib_util as util

from visit.context import Context as Context

from ast.importmodule import \
    get_full_module_name as importmodule_get_full_module_name

from ast.module import (
    get_moduledecl_child as module_get_moduledecl_child,
    get_importmember_children as module_get_importmember_children,
    get_importmodule_children as module_get_importmodule_children,
    get_payloadtypedecl_children as module_get_payloadtypedecl_children,
    get_globalprotocoldecl_children as module_get_globalprotocoldecl_children,
    get_localprotocoldecl_children as module_get_localprotocoldecl_children
)

from ast.moduledecl import (
    check_filename as moduledecl_check_file_name,
    get_full_name as moduledecl_get_full_name
)

from ast.payloadtypedecl import \
    get_declaration_name as payloadtypedecl_get_declaration_name

from ast.globel.globalprotocoldecl import \
    get_name as globalprotocoldecl_get_name

from ast.local.localprotocoldecl import \
    get_name as localprotocoldecl_get_name


# Section 4.2 -- dependencies of the primary module
def load_modules(context_, filepath, module_):
    return _add_module_and_get_dependencies(context_, filepath, module_)


def _add_module_and_get_dependencies(context_, filepath, current):
    # Section 4.2 -- Simple moduledecl name and filename of module
    #
    # Move to well-formedness? (Currently also checked for well-formed
    # moduledecl, but commenting this line here causes some problems for
    # mutually recursive imports -- should debug this)
    moduledecl_ = module_get_moduledecl_child(current)
    moduledecl_check_file_name(filepath, moduledecl_)
    fmn = moduledecl_get_full_name(moduledecl_)

    context_ = context_.add_source(fmn, filepath)
    # Make a combined add_source and add_module method for Context? (And move the
    # above name check into there)
    context_ = context_.add_module(fmn, current)
    #context_ = _add_all_members(context_, fmn, current)
        # Done later by memberloader

    importmodules = module_get_importmodule_children(current)
    for i in importmodules:
        fmn = importmodule_get_full_module_name(i)
        # sources and modules keys should match
        if fmn not in context_.get_modules().keys():
            tmp = util.convert_full_module_name_to_filepath(fmn)
            filepath = util.search_importpath_for_file(context_.import_path,
                                                       tmp)
            module_ = util.load_file_and_parse_module(filepath)
            #  # We found a parseable Scribble module at that file path -- but
            #  module decl not checked yet (checked by well-formedness, along
            #  with other well-formedness conditions) We found a parseable
            #  Scribble module at that file path -- but module decl not checked
            #  yet (checked by well-formedness, along with other well-formedness
            #  conditions)
            context_ = _add_module_and_get_dependencies(context_,
                                                        filepath,
                                                        module_)
    """importmembers = module.module_get_importmember_children(current)  # TODO: member imports"""

    return context_


"""# Same structure as visibilitybuilder.get_moduleMembers
def _add_all_members(context_, fmn, module_):
    for ptd in module_get_payloadtypedecl_children(module_):
        n = payloadtypedecl_get_declaration_name(ptd)
        f = fmn + '.' + n
        context_ = context_.add_member(f, ptd)
    for gpd in module_get_globalprotocoldecl_children(module_):
        n = globalprotocoldecl_get_name(gpd)
        f = fmn + '.' + n
        context_ = context_.add_member(f, gpd)
    for lpd in module_get_localprotocoldecl_children(module_):
        n = localprotocoldecl_get_name(lpd)
        f = fmn + '.' + n
        context_ = context_.add_member(f, lpd)
    importmembers = module_get_importmember_children(module_)
    for im in importmembers:
        # TODO: members
        util.report_error("TODO member import: " + im)
    return context_"""