// Copyright 2018 oooutlk@outlook.com. See the COPYRIGHT
// file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! # Project Goal
//! To provide a mechanism for upstream crates to collect information from
//! downstream crates.
//!
//! # Information collected from downstream crates
//!
//! Invoking `collect_downstream()` will collect the following information from
//! crates which called `register()` in its `build.rs`.
//!
//! - Package name.
//!
//! - Metadata defined in `Cargo.toml`.
//!
//! - Manifest paths of `Cargo.toml`.
//!
//! - Source file paths(optional). Call `collect_downstream()` with the argument
//! `inwelling::Opt::dump_rs_paths == true` to collect.
//!
//! # Quickstart
//!
//! 1. The upstream crate e.g. `crate foo` calls `inwelling::collect_downstream()`
//!    in its `build.rs` and do whatever it want to generate APIs for downstream.
//!
//! 2. The downstream crate e.g. `crate bar` calls `inwelling::register()` in its
//!    `build.rs`.
//!
//!    ```rust,no_run
//!    // build.rs
//!    fn main() { inwelling::register(); }
//!    ```
//!
//!    To send some metadata to upstream `crate foo`, encode them in `Cargo.toml`'s
//!    package metadata.
//!
//!    ```toml
//!    [package.metadata.inwelling.foo]
//!    answer = { type = "integer", value = "42" }
//!    ```

use std::{
    collections::HashSet,
    env,
    fs,
    path::{Path, PathBuf},
};

/// Information collected from downstream crates.
#[derive( Debug )]
pub struct Downstream {
    pub packages : Vec<Package>,
}

impl Default for Downstream {
    fn default() -> Self {
        Downstream{ packages: Vec::new() }
    }
}

/// Information collected from one downstream crate. Including:
///
/// - Package name.
///
/// - Cargo.toml file' path.
///
/// - metadata from `[package.metadata.inwelling.*]` section in Cargo.toml file.
///
/// - Optional .rs file paths.
#[derive( Debug )]
pub struct Package {
    /// name of the package which called `register()` in its `build.rs`.
    pub name     : String,
    /// path of `Cargo.toml`.
    pub manifest : PathBuf,
    /// metadata represented in Toml.
    pub metadata : toml::Value,
    /// .rs files under src/, examples/ and tests/ directories if `dump_rs_file`
    /// is true, otherwise `None`.
    pub rs_paths : Option<Vec<PathBuf>>,
}

fn scan_rs_paths( current_dir: impl AsRef<Path>, rs_paths: &mut Vec<PathBuf> ) {
    if let Ok( entries ) = current_dir.as_ref().read_dir() {
        for entry in entries {
            if let Ok( entry ) = entry {
                let path = entry.path();
                if path.is_dir() {
                    scan_rs_paths( path, rs_paths );
                } else if let Some( extention ) = path.extension() {
                    if extention == "rs" {
                        rs_paths.push( path );
                    }
                }
            }
        }
    }
}

/// Options passed to inwelling().
pub struct Opts {
    /// build.rs using inwelling() will re-run if downstream crates' Cargo.toml files have been changed.
    pub watch_manifest : bool,
    /// build.rs using inwelling() will re-run if downstream crates' .rs files have been changed.
    pub watch_rs_files : bool,
    /// if this flag is true, inwelling()'s returning value will contain .rs file paths.
    pub dump_rs_paths  : bool,
}

impl Default for Opts {
    fn default() -> Opts {
        Opts {
            watch_manifest : true,
            watch_rs_files : false,
            dump_rs_paths  : false,
        }
    }
}

/// Collects information from downstream crates. Including:
///
/// - Package names.
///
/// - Cargo.toml files' paths.
///
/// - metadata from `[package.metadata.inwelling.*]` sections in Cargo.toml files.
///
/// - Optional .rs file paths.
pub fn collect_downstream( Opts{ watch_manifest, watch_rs_files, dump_rs_paths }: Opts ) -> Downstream {
    let manifest_paths = locate_manifest_paths();

    let build_name = env::var("CARGO_PKG_NAME").expect("CARGO_PKG_NAME");

    manifest_paths.into_iter().fold( Downstream::default(), |mut inwelling, manifest_path| {
        let cargo_toml =
            fs::read_to_string( PathBuf::from( &manifest_path ))
            .expect( &format!( "to read {:?}", manifest_path ))
            .parse::<toml::Table>()
            .expect( &format!( "{:?} should be a valid manifest", manifest_path ));
        let package = cargo_toml.get( "package" )
            .expect( &format!( "{:?} should contain '[package]' section", manifest_path ));
        let package_name = package.as_table()
            .expect( &format!( "[package] section in {:?} should contain key-value pair(s)", manifest_path ))
            .get( "name" )
            .expect( &format!( "{:?} should contain package name", manifest_path ))
            .as_str()
            .expect( &format!( "{:?}'s package name should be a string", manifest_path ))
            .to_owned();

        let mut rs_paths = Vec::new();

        if watch_manifest {
            println!( "cargo:rerun-if-changed={}", manifest_path.to_str().unwrap() );
        }
        if dump_rs_paths || watch_rs_files {
            let manifest_dir = manifest_path.parent().unwrap();
            scan_rs_paths( &manifest_dir.join( "src"      ), &mut rs_paths );
            scan_rs_paths( &manifest_dir.join( "examples" ), &mut rs_paths );
            scan_rs_paths( &manifest_dir.join( "tests"    ), &mut rs_paths );
            if watch_rs_files {
                rs_paths.iter().for_each( |rs_file|
                    println!( "cargo:rerun-if-changed={}", rs_file.to_str().unwrap() ));
            }
        }
        if let Some( metadata ) = package.get( "metadata" ) {
            if let Some( metadata_inwelling ) = metadata.get("inwelling") {
                if let Some( metadata_inwelling_build ) = metadata_inwelling.get( &build_name ) {
                    inwelling.packages.push( Package{
                        name     : package_name,
                        manifest : manifest_path,
                        metadata : metadata_inwelling_build.clone(),
                        rs_paths : if dump_rs_paths { Some( rs_paths )} else { None },
                    });
                }
            }
        }

        inwelling
    })
}

// the path of the file that stores the downstream crate's manifest directory.
const MANIFEST_DIR_INWELLING: &'static str = "manifest_dir.inwelling";

fn locate_manifest_paths() -> HashSet<PathBuf> {
    let mut path_bufs = HashSet::new();

    let out_dir = PathBuf::from( env::var( "OUT_DIR" ).expect( "$OUT_DIR should exist." ));
    let ancestors = out_dir.ancestors();
    let build_dir = ancestors.skip(2).next().expect( "'build' directory should exist." );

    for  entry in build_dir.read_dir().expect( &format!( "to list all sub dirs in {:?}", build_dir )) {
        if let Ok( entry ) = entry {
            let path = entry.path();
            if path.is_dir() {
                let manifest_path_txt = path.join("out").join( MANIFEST_DIR_INWELLING );
                if manifest_path_txt.exists() {
                     path_bufs.insert(
                         PathBuf::from(
                             fs::read_to_string( &manifest_path_txt )
                                 .expect( &format!( "to read {:?} to get one manifest path", manifest_path_txt )))
                         .join( "Cargo.toml" )
                     );
                }
            }
        }
    }
    path_bufs
}

/// Allow some upstream crate to collect information from this crate.
pub fn register() {
    let out_path =
        PathBuf::from(
            env::var( "OUT_DIR" )
                .expect( "$OUT_DIR should exist." )
        ).join( MANIFEST_DIR_INWELLING );
    let manifest_dir =
        env::var( "CARGO_MANIFEST_DIR" )
            .expect( "$CARGO_MANIFEST_DIR should exist." );
    fs::write(
        out_path,
        manifest_dir
    ).expect( "manifest_dir.txt generated." );
}