//! Validates all used crates and extern libraries and loads their metadata

use syntax::diagnostic::span_handler;
use syntax::{ast, ast_util};
use syntax::attr;
use syntax::visit;
use syntax::codemap::span;
use std::map::HashMap;
use syntax::print::pprust;
use filesearch::filesearch;
use common::*;
use dvec::DVec;
use syntax::parse::token::ident_interner;

export read_crates;

// Traverses an AST, reading all the information about use'd crates and extern
// libraries necessary for later resolving, typechecking, linking, etc.
fn read_crates(diag: span_handler, crate: ast::crate,
               cstore: cstore::cstore, filesearch: filesearch,
               os: loader::os, static: bool, intr: ident_interner) {
    let e = @{diag: diag,
              filesearch: filesearch,
              cstore: cstore,
              os: os,
              static: static,
              crate_cache: DVec(),
              mut next_crate_num: 1,
              intr: intr};
    let v =
        visit::mk_simple_visitor(@{visit_view_item:
                                       |a| visit_view_item(e, a),
                                   visit_item: |a| visit_item(e, a)
                                   ,.. *visit::default_simple_visitor()});
    visit::visit_crate(crate, (), v);
    dump_crates(e.crate_cache);
    warn_if_multiple_versions(e, diag, e.crate_cache.get());
}

type cache_entry = {
    cnum: int,
    span: span,
    hash: ~str,
    metas: @~[ast::meta_item]
};

fn dump_crates(crate_cache: DVec<cache_entry>) {
    debug!("resolved crates:");
    for crate_cache.each |entry| {
        debug!("cnum: %?", entry.cnum);
        debug!("span: %?", entry.span);
        debug!("hash: %?", entry.hash);
    }
}

fn warn_if_multiple_versions(e: env, diag: span_handler,
                             crate_cache: ~[cache_entry]) {
    use either::*;

    if crate_cache.len() != 0u {
        let name = loader::crate_name_from_metas(*crate_cache.last().metas);
        let {lefts: matches, rights: non_matches} =
            partition(crate_cache.map_to_vec(|entry| {
                let othername = loader::crate_name_from_metas(*entry.metas);
                if name == othername {
                    Left(entry)
                } else {
                    Right(entry)
                }
            }));

        assert matches.is_not_empty();

        if matches.len() != 1u {
            diag.handler().warn(
                fmt!("using multiple versions of crate `%s`", name));
            for matches.each |match_| {
                diag.span_note(match_.span, ~"used here");
                let attrs = ~[
                    attr::mk_attr(attr::mk_list_item(~"link", *match_.metas))
                ];
                loader::note_linkage_attrs(e.intr, diag, attrs);
            }
        }

        warn_if_multiple_versions(e, diag, non_matches);
    }
}

type env = @{diag: span_handler,
             filesearch: filesearch,
             cstore: cstore::cstore,
             os: loader::os,
             static: bool,
             crate_cache: DVec<cache_entry>,
             mut next_crate_num: ast::crate_num,
             intr: ident_interner};

fn visit_view_item(e: env, i: @ast::view_item) {
    match i.node {
      ast::view_item_use(ident, meta_items, id) => {
        debug!("resolving use stmt. ident: %?, meta: %?", ident, meta_items);
        let cnum = resolve_crate(e, ident, meta_items, ~"", i.span);
        cstore::add_use_stmt_cnum(e.cstore, id, cnum);
      }
      _ => ()
    }
}

fn visit_item(e: env, i: @ast::item) {
    match i.node {
      ast::item_foreign_mod(fm) => {
        match attr::foreign_abi(i.attrs) {
          either::Right(abi) => {
            if abi != ast::foreign_abi_cdecl &&
               abi != ast::foreign_abi_stdcall { return; }
          }
          either::Left(msg) => e.diag.span_fatal(i.span, msg)
        }

        let cstore = e.cstore;
        let mut already_added = false;
        let link_args = attr::find_attrs_by_name(i.attrs, ~"link_args");

        match fm.sort {
          ast::named => {
            let foreign_name =
               match attr::first_attr_value_str_by_name(i.attrs,
                                                        ~"link_name") {
                 Some(nn) => {
                   if nn == ~"" {
                      e.diag.span_fatal(
                          i.span,
                          ~"empty #[link_name] not allowed; use #[nolink].");
                   }
                   nn
                 }
                None => *e.intr.get(i.ident)
            };
            if attr::find_attrs_by_name(i.attrs, ~"nolink").is_empty() {
                already_added = !cstore::add_used_library(cstore,
                                                          foreign_name);
            }
            if link_args.is_not_empty() && already_added {
                e.diag.span_fatal(i.span, ~"library '" + foreign_name +
                           ~"' already added: can't specify link_args.");
            }
          }
          ast::anonymous => { /* do nothing */ }
        }

        for link_args.each |a| {
            match attr::get_meta_item_value_str(&attr::attr_meta(*a)) {
              Some(linkarg) => {
                cstore::add_used_link_args(cstore, linkarg);
              }
              None => {/* fallthrough */ }
            }
        }
      }
      _ => { }
    }
}

fn metas_with(ident: ~str, key: ~str, metas: ~[ast::meta_item])
    -> ~[ast::meta_item] {
    let name_items = attr::find_meta_items_by_name(metas, key);
    if name_items.is_empty() {
        vec::append_one(metas, attr::mk_name_value_item_str(key, ident))
    } else {
        metas
    }
}

fn metas_with_ident(ident: ~str, metas: ~[ast::meta_item])
    -> ~[ast::meta_item] {
    metas_with(ident, ~"name", metas)
}

fn existing_match(e: env, metas: ~[ast::meta_item], hash: ~str) ->
    Option<int> {

    for e.crate_cache.each |c| {
        if loader::metadata_matches(*c.metas, metas)
            && (hash.is_empty() || c.hash == hash) {
            return Some(c.cnum);
        }
    }
    return None;
}

fn resolve_crate(e: env, ident: ast::ident, metas: ~[ast::meta_item],
                 hash: ~str, span: span) -> ast::crate_num {
    let metas = metas_with_ident(*e.intr.get(ident), metas);

    match existing_match(e, metas, hash) {
      None => {
        let load_ctxt: loader::ctxt = {
            diag: e.diag,
            filesearch: e.filesearch,
            span: span,
            ident: ident,
            metas: metas,
            hash: hash,
            os: e.os,
            static: e.static,
            intr: e.intr
        };
        let cinfo = loader::load_library_crate(load_ctxt);

        let cfilename = Path(cinfo.ident);
        let cdata = cinfo.data;

        let attrs = decoder::get_crate_attributes(cdata);
        let linkage_metas = attr::find_linkage_metas(attrs);
        let hash = decoder::get_crate_hash(cdata);

        // Claim this crate number and cache it
        let cnum = e.next_crate_num;
        e.crate_cache.push({cnum: cnum, span: span,
                            hash: hash, metas: @linkage_metas});
        e.next_crate_num += 1;

        // Now resolve the crates referenced by this crate
        let cnum_map = resolve_crate_deps(e, cdata);

        let cname =
            match attr::last_meta_item_value_str_by_name(metas, ~"name") {
              option::Some(v) => v,
              option::None => *e.intr.get(ident)
            };
        let cmeta = @{name: cname, data: cdata,
                      cnum_map: cnum_map, cnum: cnum};

        let cstore = e.cstore;
        cstore::set_crate_data(cstore, cnum, cmeta);
        cstore::add_used_crate_file(cstore, &cfilename);
        return cnum;
      }
      Some(cnum) => {
        return cnum;
      }
    }
}

// Go through the crate metadata and load any crates that it references
fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map {
    debug!("resolving deps of external crate");
    // The map from crate numbers in the crate we're resolving to local crate
    // numbers
    let cnum_map = HashMap::<int,ast::crate_num>();
    for decoder::get_crate_deps(e.intr, cdata).each |dep| {
        let extrn_cnum = dep.cnum;
        let cname = dep.name;
        let cmetas = metas_with(dep.vers, ~"vers", ~[]);
        debug!("resolving dep crate %s ver: %s hash: %s",
               *e.intr.get(dep.name), dep.vers, dep.hash);
        match existing_match(e, metas_with_ident(*e.intr.get(cname), cmetas),
                             dep.hash) {
          Some(local_cnum) => {
            debug!("already have it");
            // We've already seen this crate
            cnum_map.insert(extrn_cnum, local_cnum);
          }
          None => {
            debug!("need to load it");
            // This is a new one so we've got to load it
            // FIXME (#2404): Need better error reporting than just a bogus
            // span.
            let fake_span = ast_util::dummy_sp();
            let local_cnum = resolve_crate(e, cname, cmetas, dep.hash,
                                           fake_span);
            cnum_map.insert(extrn_cnum, local_cnum);
          }
        }
    }
    return cnum_map;
}

// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End: