/**
 **      ==============================
 **       OOOO        O      O   OOOO
 **       O   O       O     O O  O   O
 **       O   O       O     O O  O   O
 **       OOOO   OOOO O     OOO  OOOO
 **       O   O       O    O   O O   O
 **       O   O       O    O   O O   O
 **       OOOO        OOOO O   O OOOO
 **      ==============================
 **      Dr. Stefan Bosse http://www.bsslab.de
 **
 **      COPYRIGHT: THIS SOFTWARE, EXECUTABLE AND SOURCE CODE IS OWNED
 **                 BY THE AUTHOR(S).
 **                 THIS SOURCE CODE MAY NOT BE COPIED, EXTRACTED,
 **                 MODIFIED, OR OTHERWISE USED IN A CONTEXT
 **                 OUTSIDE OF THE SOFTWARE SYSTEM.
 **
 **    $AUTHORS:     Stefan Bosse
 **    $INITIAL:     (C) 2006-2020 bLAB
 **    $CREATED:     20-10-16 by sbosse.
 **    $VERSION:     1.2.1
 **
 **    $INFO:
 **
 **  GEO IP Database Services and http/https Server
 **  Database source: GeoLiteCit
 **  Compatibility: ip-api.com/json 
 **  Can be used as a proxy to ip-api.com to overcome ad-blockers!
 **
 **  Look-up returns:
 ** {
 **   country: string, // country
 **   countryCode: string, // countryCode
 **   region: string, // region
 **   city: string, // city
 **   zip: string, // postal code
 **   lat: string, // latitude
 **   lon: string  // longitude
 **  }; 
 **
 **    $ENDOFINFO
 */
var fs = require("fs");
var sat = Require('dos/ext/satelize');

var out = function (msg) { console.log('[GEOIP] '+msg) };

var geoip = module.exports = {
    dir : process.cwd()||__dirname,
    ipblocks : [],
    locations : [],
	midpoints : [],
	numblocks : 0,
    ready : 0,
    verbose : 0,
    config : function (a,v) { geoip[a]=v }, 

    // Cold start, load and compile CSV DB
    init : function (cb) {
      out ('Loading '+ geoip.dir + "/GeoLiteCity-Blocks.csv ..");
      var block = fs.createReadStream(geoip.dir + "/GeoLiteCity-Blocks.csv");
      out ('Loading '+ geoip.dir + "/GeoLiteCity-Location.csv ..");
      var location = fs.createReadStream(geoip.dir + "/GeoLiteCity-Location.csv");
      var buffer1 = "",buffer2 = "";

      block.addListener("data", function(data) {
          buffer1 += data.toString().replace(/"/g, "");
      });

      block.addListener("end", function() {
          var entries = buffer1.split("\n");
          out ('Compiling GeoLiteCity-Blocks ..');
          for(var i=0; i<entries.length; i++) {
              if (i<2) continue;        
              var entry = entries[i].split(",");
              if (parseInt(entry[0])) geoip.ipblocks.push({
                a: parseInt(entry[0]), // ip start
                b: parseInt(entry[1]), // ip end
                i: parseInt(entry[2])  // location id
              });
          }

          geoip.ipblocks.sort(function(a, b) {
              return a.a - b.a;
          });
          geoip.numblocks = geoip.ipblocks.length;
          geoip.midpoints=[];
          var n = Math.floor(geoip.numblocks / 2);
          while(n >= 1) {
              n = Math.floor(n / 1.5);
              geoip.midpoints.push(n);
          }

		  geoip.ready++;
          if (cb && geoip.ready==2) cb();
      });

      location.addListener("data", function(data) {
          buffer2 += data.toString().replace(/"/g, "");
      });

      location.addListener("end", function() {

          var entries = buffer2.split("\n");
          var locid=0;
          out ('Compiling GeoLiteCity-Location ..');

          for(var i=0; i<entries.length; i++) {
              if (i<2) continue;        
              var entry = entries[i].split(",");
              locid=parseInt(entry[0]);
              geoip.locations[locid] = {
                cn: entry[1], // country
                re: entry[2], // region
                ci: entry[3], // city
                pc: entry[4], // postal code
                la: entry[5], // latitude
                lo: entry[6]  // longitude
              };
          }

		  geoip.ready++;
          if (cb && geoip.ready==2) cb();
      });    
    },

    // Load and parse JSON DB
    load : function (cb) {
      // Read DB
      out ('Loading '+geoip.dir + "/GeoLiteCity-Blocks.json ..");
      var block = fs.createReadStream(geoip.dir + "/GeoLiteCity-Blocks.json");
      out ('Loading '+geoip.dir + "/GeoLiteCity-Location.json ..");
      var location = fs.createReadStream(geoip.dir + "/GeoLiteCity-Location.json");
      var buffer1 = "",buffer2 = "";
      block.on('error', function (e) { out(e); cb(e); });
      location.on('error', function (e) { out(e); cb(e); });
      
      block.addListener("data", function(data) {
          buffer1 += data.toString();
      });

      block.addListener("end", function() {
          out ('Parsing GeoLiteCity-Blocks ..');
          geoip.ipblocks = JSON.parse(buffer1);
          out ('Parsing GeoLiteCity-Blocks done.');
          geoip.ipblocks.sort(function(a, b) {
              return a.a - b.a;
          });
          geoip.numblocks = geoip.ipblocks.length;
          var n = Math.floor(geoip.numblocks / 2);
          geoip.midpoints=[];
          while(n >= 1) {
              n = Math.floor(n / 1.5);
              geoip.midpoints.push(n);
          }
		  geoip.ready++;
          if (cb && geoip.ready==2) cb();
      });

      location.addListener("data", function(data) {
          buffer2 += data.toString();
      });

      location.addListener("end", function() {
          out ('Parsing GeoLiteCity-Location ..');
          geoip.locations = JSON.parse(buffer2);
          out ('Parsing GeoLiteCity-Location done.');

		  geoip.ready++;
          if (cb && geoip.ready==2) cb();
      });
      
    },

    // Search a matching GEO entry
    lookup: function(ip) {

        if(geoip.ready<2) {
            return { error: "GeoIP not ready" };
        }

        var ipl = iplong(ip);

        if(ipl == 0) {
            return { error: "Invalid ip address " + ip + " -> " + ipl + " as integer" };
        }

        var found = find(ipl);
        if (found) {
          var loc = geoip.locations[found.i]; 
          return {
            status:"success",
            country: getCountryName(loc.cn),
            countryCode:loc.cn,
            city:loc.ci,
            region:loc.re,
            zip:loc.pc,
            lon:loc.lo,
            lat:loc.la,
          }
        } else return none;
    },
    
    // ip-api.com relay using satelize module!
    proxy : function (options) {
      options=options||{http:9999};
      var http = require('http');
      var https;
      try { https = require('https') } catch (e) { }
      if (options.http) {
        var httpSrv = http.createServer(function (request,response) {
          var url=request.url,body,header,sep,query,now,
              remote=request.connection.remoteAddress;
          if (request.url.length) 
            query=parseQueryString(request.remote||request.url);
          else 
            query={}
          if (url.match(/\/json\/([0-9\.]+)/)) query.ip=url.match(/\/json\/([0-9\.]+)/)[1];
          if (geoip.verbose>0) print(url,query,remote);
          switch (request.method) {
            case 'GET':
              sat.satelize({ip:query.ip||remote},function (err,info) {
                   if (err) {
                     return reply(response,JSON.stringify({error:err}))
                   } else {
                     if (request.headers && request.headers.host) info.proxy=request.headers.host;
                     return reply(response,JSON.stringify(info))                       
                   }
              })

              break;
          }
        });
        httpSrv.on("connection", function (socket) {
            // socket.setNoDelay(true);
        });

        httpSrv.on("error", function (err) {
          out(err)
        });

        httpSrv.listen(options.http,function (err) {
          out('HTTP server started on port '+options.http);
        });
      };
      if (options.https && https && options.pem) {
          // requires options.pem={key,cert} 
        var httpsSrv = https.createServer(options.pem,function (request,response) {
          var url=request.url,body,header,sep,query,now,
              remote=request.connection.remoteAddress;
          if (request.url.length) 
            query=parseQueryString(request.remote||request.url);
          else 
            query={}
          if (url.match(/\/json\/([0-9\.]+)/)) query.ip=url.match(/\/json\/([0-9\.]+)/)[1];
          if (geoip.verbose>0) print(url,query,remote);
          switch (request.method) {
            case 'GET':
              sat.satelize({ip:query.ip||remote},function (err,info) {
                   if (err) {
                     return reply(response,JSON.stringify({error:err}))
                   } else {
                     if (request.headers && request.headers.host) info.proxy=request.headers.host;
                     return reply(response,JSON.stringify(info))                       
                   }
              })

              break;
          }
        });
        httpsSrv.on("connection", function (socket) {
            // socket.setNoDelay(true);
        });

        httpsSrv.on("error", function (err) {
          out(err)
        });

        httpsSrv.listen(options.https,function (err) {
          out('HTTPS server started on port '+options.https);
        });
      };
    },
    
    // Start an ip-api.com compatible web server API
    server : function (options) {
      options=options||{http:{address:'localhost',port:9999}};
      var http = require('http');
      var https;
      try { https = require('https') } catch (e) { }
      geoip.load(function (err) {
        if (err) return;
        if (options.http) {
          var httpSrv = http.createServer(function (request,response) {
            var url=request.url,body,header,sep,query,now,
                remote=request.connection.remoteAddress;
            if (request.url.length) 
              query=parseQueryString(request.remote||request.url);
            else 
              query={}
            if (url.match(/\/json\/([0-9\.]+)/)) query.ip=url.match(/\/json\/([0-9\.]+)/)[1];
            if (geoip.verbose>0) print(url,query,remote);
            switch (request.method) {
              case 'GET':
                reply(response,JSON.stringify(geoip.lookup(query.ip||remote)))
                break;
            }
          })

          httpSrv.on("connection", function (socket) {
              // socket.setNoDelay(true);
          });

          httpSrv.on("error", function (err) {
            out(err)
          });

          httpSrv.listen(options.http.port,function (err) {
            out('HTTP server started on port '+options.http.port);
          });
        }
        if (options.https && https && options.pem) {
          // requires options.pem={key,cert} 
          var httpsSrv = https.createServer(options.pem,function (request,response) {
            var url=request.url,body,header,sep,query,now,
                remote=request.connection.remoteAddress;
            if (request.url.length) 
              query=parseQueryString(request.remote||request.url);
            else 
              query={}
            if (url.match(/\/json\/([0-9\.]+)/)) query.ip=url.match(/\/json\/([0-9\.]+)/)[1];
            if (geoip.verbose>0) print(url,query,remote);
            switch (request.method) {
              case 'GET':
                reply(response,JSON.stringify(geoip.lookup(query.ip||remote)))
                break;
            }
          })

          httpsSrv.on("connection", function (socket) {
              // socket.setNoDelay(true);
          });

          httpsSrv.on("error", function (err) {
            out(err)
          });

          httpsSrv.listen(options.http.port,function (err) {
            out('HTTPS server started on port '+options.http.port);
          });
        }
      });
    },

    // Save the DB in JSON format
    save : function () {
      out ('Saving '+geoip.dir + "/GeoLiteCity-Blocks.json ..");
      var jsblocks = JSON.stringify(geoip.ipblocks);
      fs.writeFileSync(geoip.dir + "/GeoLiteCity-Blocks.json", jsblocks, 'utf8');
      out ('Saving '+geoip.dir + "/GeoLiteCity-Location.json ..");
      var jslocations = JSON.stringify(geoip.locations);
      fs.writeFileSync(geoip.dir + "/GeoLiteCity-Location.json", jslocations, 'utf8');
    },
    
};

function iplong(ip) {

    if(!ip) {
        return 0;
    }

    ip = ip.toString();

    if(isNaN(ip) && ip.indexOf(".") == -1) {
        return 0;
    }

    if(ip.indexOf(".") == -1) {

        try {
            ip = parseFloat(ip);
            return ip < 0 || ip > 4294967296 ? 0 : ip;
        }
        catch(s) {
        }
    }

    var parts = ip.split(".");

    if(parts.length != 4) {
        return 0;
    }

    var ipl = 0;

    for(var i=0; i<4; i++) {
        parts[i] = parseInt(parts[i], 10);

        if(parts[i] < 0 || parts[i] > 255) {
            return 0;
        }

        ipl += parts[3-i] * (Math.pow(256, i));
    }

    return ipl > 4294967296 ? 0 : ipl;
}

/**
 * A qcuick little binary search
 * @param ip the ip we're looking for
 * @return {*}
 */
function find(ipl) {

    var mpi = 0;
    var n = geoip.midpoints[0];
    var step;
    var current;
    var next;
    var prev;
    var nn;
    var pn;
    while(true) {

        step = geoip.midpoints[mpi];
        mpi++;
        current = geoip.ipblocks[n];
        nn = n + 1;
        pn = n - 1;

        next = nn < geoip.numblocks ? geoip.ipblocks[nn] : null;
        prev = pn > -1 ? geoip.ipblocks[pn] : null;
        
		// take another step?
        if(step > 0) {
            if(!next || next.a < ipl) {
                n += step;
            } else {
                n -= step;
            }

            continue;
        }

        // we're either current, next or previous depending on which is closest to ipl
        var cd = Math.abs(ipl - current.a);
        var nd = next && next.a < ipl ? ipl - next.a : 1000000000;
        var pd = prev && prev.a < ipl ? ipl - prev.a : 1000000000;


        // current wins
        if(cd < nd && cd < pd) {
            return current;
        }

         // next wins
        if(nd < cd && nd < pd) {
            return next;

        }

        // prev wins
        return prev;
    }
    return none;
}

// https://gist.github.com/maephisto

var isoCountries = {
    'AF' : 'Afghanistan',
    'AX' : 'Aland Islands',
    'AL' : 'Albania',
    'DZ' : 'Algeria',
    'AS' : 'American Samoa',
    'AD' : 'Andorra',
    'AO' : 'Angola',
    'AI' : 'Anguilla',
    'AQ' : 'Antarctica',
    'AG' : 'Antigua And Barbuda',
    'AR' : 'Argentina',
    'AM' : 'Armenia',
    'AW' : 'Aruba',
    'AU' : 'Australia',
    'AT' : 'Austria',
    'AZ' : 'Azerbaijan',
    'BS' : 'Bahamas',
    'BH' : 'Bahrain',
    'BD' : 'Bangladesh',
    'BB' : 'Barbados',
    'BY' : 'Belarus',
    'BE' : 'Belgium',
    'BZ' : 'Belize',
    'BJ' : 'Benin',
    'BM' : 'Bermuda',
    'BT' : 'Bhutan',
    'BO' : 'Bolivia',
    'BA' : 'Bosnia And Herzegovina',
    'BW' : 'Botswana',
    'BV' : 'Bouvet Island',
    'BR' : 'Brazil',
    'IO' : 'British Indian Ocean Territory',
    'BN' : 'Brunei Darussalam',
    'BG' : 'Bulgaria',
    'BF' : 'Burkina Faso',
    'BI' : 'Burundi',
    'KH' : 'Cambodia',
    'CM' : 'Cameroon',
    'CA' : 'Canada',
    'CV' : 'Cape Verde',
    'KY' : 'Cayman Islands',
    'CF' : 'Central African Republic',
    'TD' : 'Chad',
    'CL' : 'Chile',
    'CN' : 'China',
    'CX' : 'Christmas Island',
    'CC' : 'Cocos (Keeling) Islands',
    'CO' : 'Colombia',
    'KM' : 'Comoros',
    'CG' : 'Congo',
    'CD' : 'Congo, Democratic Republic',
    'CK' : 'Cook Islands',
    'CR' : 'Costa Rica',
    'CI' : 'Cote D\'Ivoire',
    'HR' : 'Croatia',
    'CU' : 'Cuba',
    'CY' : 'Cyprus',
    'CZ' : 'Czech Republic',
    'DK' : 'Denmark',
    'DJ' : 'Djibouti',
    'DM' : 'Dominica',
    'DO' : 'Dominican Republic',
    'EC' : 'Ecuador',
    'EG' : 'Egypt',
    'SV' : 'El Salvador',
    'GQ' : 'Equatorial Guinea',
    'ER' : 'Eritrea',
    'EE' : 'Estonia',
    'ET' : 'Ethiopia',
    'FK' : 'Falkland Islands (Malvinas)',
    'FO' : 'Faroe Islands',
    'FJ' : 'Fiji',
    'FI' : 'Finland',
    'FR' : 'France',
    'GF' : 'French Guiana',
    'PF' : 'French Polynesia',
    'TF' : 'French Southern Territories',
    'GA' : 'Gabon',
    'GM' : 'Gambia',
    'GE' : 'Georgia',
    'DE' : 'Germany',
    'GH' : 'Ghana',
    'GI' : 'Gibraltar',
    'GR' : 'Greece',
    'GL' : 'Greenland',
    'GD' : 'Grenada',
    'GP' : 'Guadeloupe',
    'GU' : 'Guam',
    'GT' : 'Guatemala',
    'GG' : 'Guernsey',
    'GN' : 'Guinea',
    'GW' : 'Guinea-Bissau',
    'GY' : 'Guyana',
    'HT' : 'Haiti',
    'HM' : 'Heard Island & Mcdonald Islands',
    'VA' : 'Holy See (Vatican City State)',
    'HN' : 'Honduras',
    'HK' : 'Hong Kong',
    'HU' : 'Hungary',
    'IS' : 'Iceland',
    'IN' : 'India',
    'ID' : 'Indonesia',
    'IR' : 'Iran, Islamic Republic Of',
    'IQ' : 'Iraq',
    'IE' : 'Ireland',
    'IM' : 'Isle Of Man',
    'IL' : 'Israel',
    'IT' : 'Italy',
    'JM' : 'Jamaica',
    'JP' : 'Japan',
    'JE' : 'Jersey',
    'JO' : 'Jordan',
    'KZ' : 'Kazakhstan',
    'KE' : 'Kenya',
    'KI' : 'Kiribati',
    'KR' : 'Korea',
    'KW' : 'Kuwait',
    'KG' : 'Kyrgyzstan',
    'LA' : 'Lao People\'s Democratic Republic',
    'LV' : 'Latvia',
    'LB' : 'Lebanon',
    'LS' : 'Lesotho',
    'LR' : 'Liberia',
    'LY' : 'Libyan Arab Jamahiriya',
    'LI' : 'Liechtenstein',
    'LT' : 'Lithuania',
    'LU' : 'Luxembourg',
    'MO' : 'Macao',
    'MK' : 'Macedonia',
    'MG' : 'Madagascar',
    'MW' : 'Malawi',
    'MY' : 'Malaysia',
    'MV' : 'Maldives',
    'ML' : 'Mali',
    'MT' : 'Malta',
    'MH' : 'Marshall Islands',
    'MQ' : 'Martinique',
    'MR' : 'Mauritania',
    'MU' : 'Mauritius',
    'YT' : 'Mayotte',
    'MX' : 'Mexico',
    'FM' : 'Micronesia, Federated States Of',
    'MD' : 'Moldova',
    'MC' : 'Monaco',
    'MN' : 'Mongolia',
    'ME' : 'Montenegro',
    'MS' : 'Montserrat',
    'MA' : 'Morocco',
    'MZ' : 'Mozambique',
    'MM' : 'Myanmar',
    'NA' : 'Namibia',
    'NR' : 'Nauru',
    'NP' : 'Nepal',
    'NL' : 'Netherlands',
    'AN' : 'Netherlands Antilles',
    'NC' : 'New Caledonia',
    'NZ' : 'New Zealand',
    'NI' : 'Nicaragua',
    'NE' : 'Niger',
    'NG' : 'Nigeria',
    'NU' : 'Niue',
    'NF' : 'Norfolk Island',
    'MP' : 'Northern Mariana Islands',
    'NO' : 'Norway',
    'OM' : 'Oman',
    'PK' : 'Pakistan',
    'PW' : 'Palau',
    'PS' : 'Palestinian Territory, Occupied',
    'PA' : 'Panama',
    'PG' : 'Papua New Guinea',
    'PY' : 'Paraguay',
    'PE' : 'Peru',
    'PH' : 'Philippines',
    'PN' : 'Pitcairn',
    'PL' : 'Poland',
    'PT' : 'Portugal',
    'PR' : 'Puerto Rico',
    'QA' : 'Qatar',
    'RE' : 'Reunion',
    'RO' : 'Romania',
    'RU' : 'Russian Federation',
    'RW' : 'Rwanda',
    'BL' : 'Saint Barthelemy',
    'SH' : 'Saint Helena',
    'KN' : 'Saint Kitts And Nevis',
    'LC' : 'Saint Lucia',
    'MF' : 'Saint Martin',
    'PM' : 'Saint Pierre And Miquelon',
    'VC' : 'Saint Vincent And Grenadines',
    'WS' : 'Samoa',
    'SM' : 'San Marino',
    'ST' : 'Sao Tome And Principe',
    'SA' : 'Saudi Arabia',
    'SN' : 'Senegal',
    'RS' : 'Serbia',
    'SC' : 'Seychelles',
    'SL' : 'Sierra Leone',
    'SG' : 'Singapore',
    'SK' : 'Slovakia',
    'SI' : 'Slovenia',
    'SB' : 'Solomon Islands',
    'SO' : 'Somalia',
    'ZA' : 'South Africa',
    'GS' : 'South Georgia And Sandwich Isl.',
    'ES' : 'Spain',
    'LK' : 'Sri Lanka',
    'SD' : 'Sudan',
    'SR' : 'Suriname',
    'SJ' : 'Svalbard And Jan Mayen',
    'SZ' : 'Swaziland',
    'SE' : 'Sweden',
    'CH' : 'Switzerland',
    'SY' : 'Syrian Arab Republic',
    'TW' : 'Taiwan',
    'TJ' : 'Tajikistan',
    'TZ' : 'Tanzania',
    'TH' : 'Thailand',
    'TL' : 'Timor-Leste',
    'TG' : 'Togo',
    'TK' : 'Tokelau',
    'TO' : 'Tonga',
    'TT' : 'Trinidad And Tobago',
    'TN' : 'Tunisia',
    'TR' : 'Turkey',
    'TM' : 'Turkmenistan',
    'TC' : 'Turks And Caicos Islands',
    'TV' : 'Tuvalu',
    'UG' : 'Uganda',
    'UA' : 'Ukraine',
    'AE' : 'United Arab Emirates',
    'GB' : 'United Kingdom',
    'US' : 'United States',
    'UM' : 'United States Outlying Islands',
    'UY' : 'Uruguay',
    'UZ' : 'Uzbekistan',
    'VU' : 'Vanuatu',
    'VE' : 'Venezuela',
    'VN' : 'Viet Nam',
    'VG' : 'Virgin Islands, British',
    'VI' : 'Virgin Islands, U.S.',
    'WF' : 'Wallis And Futuna',
    'EH' : 'Western Sahara',
    'YE' : 'Yemen',
    'ZM' : 'Zambia',
    'ZW' : 'Zimbabwe'
};

function getCountryName (countryCode) {
    if (isoCountries.hasOwnProperty(countryCode)) {
        return isoCountries[countryCode];
    } else {
        return countryCode;
    }
}
/*
** Parse query string '?attr=val&attr=val... and return parameter record
*/
function parseQueryString( url ) {
    var queryString = url.substring( url.indexOf('?') + 1 );
    if (queryString == url) return [];
    var params = {}, queries, temp, i, l;
    // Split into key/value pairs
    queries = queryString.split("&");
    // Convert the array of strings into an object
    for ( i = 0, l = queries.length; i < l; i++ ) {
        temp = queries[i].split('=');
        if (temp[1]==undefined) temp[1]='true';
        params[temp[0]] = temp[1].replace('%20',' ');
    }
    return params;
}

function reply(response,body,mimetype) {
    header={'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Credentials': 'true',
            'Content-Type': mimetype||'text/plain'};

   response.writeHead(200,header);
   response.write(body);
   response.end();
}