Associated_species

const settings = require( '../system/settings' )
const request  = require('superagent')
const Promise  = require('bluebird')

let country = settings.country
let sources = settings.sources
let accessToken = settings.lajifi_accessToken
let pageSize = 5000

function getAssociatedSpecies( order, scientificName )
{
    // --- Species catalog is in a local cache
    //
    let speciesData = require('../../data/catalogs/' + order + '/speciesdata.js' )

    // --- Get the taxonId for the species from the species catalog
    //
    let speciesId = speciesData[scientificName].id

    //--- Get all gatherings, which contain the given species
    //
    request
    .get('https://api.laji.fi/v0/warehouse/query/list' )
    .query({
        taxonId: speciesId,
        sourceId: settings.sources,
        countryId: settings.country,
        selected: 'gathering.gatheringId',
        pageSize: pageSize,
        access_token: settings.lajifi_accessToken })
        .then( res =>
        {
            // --- Number of gatherings, can be 1000's for many Lepidoptera species
            //
            console.log( res.body.results.length + ' gatherings for ' + scientificName )

            // --- Associated species are collected in spData
            //
            let spData = {}

            // --- For parallel execution, collect all gatheringId's in an array
            //
            let gatheringQueries = []

            let gatheringQueries = res.body.results.map( item =>
            {
                return { gatheringId: item.gathering.gatheringId }
            })

            // --- Get all gatherings, max 20 concurrent requests
            //
            Promise.map( gatheringQueries, getGathering, { concurrency: 20 })
            .then( res =>
            {
                res.forEach( items =>
                {
                    // --- Each 'items' is an array of scientificNames found in a specific gathering
                    //
                    items.forEach( item =>
                    {
                        if ( item.unit && item.unit.linkings && item.unit.linkings.taxon )
                        {
                            let speciesName = item.unit.linkings.taxon.scientificName

                            // --- Collect all other names which are not equal to the name
                            //     given as the parameter for the query,
                            //     and accept only taxons in the same order
                            //
                            if ( speciesName !== scientificName && speciesData[speciesName] )
                            {
                                if ( !spData[speciesName] )
                                {
                                    let dataObj = { count: 1 }
                                    spData[speciesName] = dataObj
                                }
                                else
                                {
                                    let dataObj = spData[speciesName]
                                    dataObj.count++
                                }
                            }
                        }
                    })
                })

                // --- Convert spData into an array
                //
                let list = []
                let properties = Object.getOwnPropertyNames( spData )

                let i
                for ( i = 0; i<properties.length; i++ )
                {
                    let ljSpeciesName = properties[i]
                    let ljNbr = speciesData[ljSpeciesName].speciesNbr

                    if ( spData[ljSpeciesName].count > 1 )
                    {
                        list.push( { speciesName:ljSpeciesName, speciesNbr:ljNbr,
                                     count:spData[ljSpeciesName].count } )
                    }
                }

                 // --- Sort the list
                 //
                let sortedList = list.sort( function ( a, b )
                {
                    return a.speciesNbr - b.speciesNbr
                })

                // -- The final list of associated species
                //
                console.log( sortedList )
            })
        })
}

function getGathering( query )
{
    return request
    .get('https://api.laji.fi/v0/warehouse/query/list' )
    .query({
        gatheringId: query.gatheringId,
        sourceId: settings.sources,
        countryId: settings.country,
        selected: 'unit.linkings.taxon.scientificName',
        pageSize: pageSize,
        access_token: settings.lajifi_accessToken })
    .then( res =>
    {
        return res.body.results
    })
}

// --- An example result
//
347 gatherings for Cicindela campestris

[ { speciesName: 'Cicindela sylvatica', speciesNbr: 191, count: 5 },
  { speciesName: 'Carabus nemoralis', speciesNbr: 201, count: 2 },
  { speciesName: 'Carabus nitens', speciesNbr: 205, count: 4 },
  { speciesName: 'Calathus melanocephalus', speciesNbr: 442,  count: 2 },
  { speciesName: 'Agonum sexpunctatum', speciesNbr: 464, count: 3 },
  { speciesName: 'Phosphuga atrata', speciesNbr: 624, count: 2 },
  { speciesName: 'Cetonia aurata', speciesNbr: 1959, count: 2 },
  { speciesName: 'Protaetia cuprea', speciesNbr: 1961, count: 2 },
  { speciesName: 'Dermestes lardarius', speciesNbr: 2205, count: 2 },
  { speciesName: 'Propylea quatuordecimpunctata', speciesNbr: 2633, count: 2 },
  { speciesName: 'Calvia quatuordecimguttata', speciesNbr: 2635, count: 2 },
  { speciesName: 'Hippodamia tredecimpunctata', speciesNbr: 2639, count: 2 },
  { speciesName: 'Coccinella septempunctata', speciesNbr: 2646, count: 4 },
  { speciesName: 'Lagria hirta', speciesNbr: 2895, count: 2 },
  { speciesName: 'Hylobius abietis', speciesNbr: 3411, count: 2 } ]