//--------------------- Copyright Block ----------------------
/* 

PrayTimes.js: Prayer Times Calculator (ver 2.3)
Copyright (C) 2007-2011 PrayTimes.org

Developer: Hamid Zarrabi-Zadeh
License: GNU LGPL v3.0

TERMS OF USE:
    Permission is granted to use this code, with or 
    without modification, in any website or application 
    provided that credit is given to the original work 
    with a link back to PrayTimes.org.

This program is distributed in the hope that it will 
be useful, but WITHOUT ANY WARRANTY. 

PLEASE DO NOT REMOVE THIS COPYRIGHT BLOCK.
 
*/ 


//--------------------- Help and Manual ----------------------
/*

User's Manual: 
http://praytimes.org/manual

Calculation Formulas: 
http://praytimes.org/calculation



//------------------------ User Interface -------------------------


    getTimes (date, coordinates [, timeZone [, dst [, timeFormat]]]) 
    
    setMethod (method)       // set calculation method 
    adjust (parameters)      // adjust calculation parameters   
    tune (offsets)           // tune times by given offsets 

    getMethod ()             // get calculation method 
    getSetting ()            // get current calculation parameters
    getOffsets ()            // get current time offsets


//------------------------- Sample Usage --------------------------


    var PT = new PrayTimes('ISNA');
    var times = PT.getTimes(new Date(), [43, -80], -5);
    document.write('Sunrise = '+ times.sunrise)


*/
    

//----------------------- PrayTimes Class ------------------------


function PrayTimes(method) {


    //------------------------ Constants --------------------------
    var
    
    // Time Names
    timeNames = {
        imsak    : 'Imsak',
        fajr     : 'Fajr',
        sunrise  : 'Sunrise',
        dhuhr    : 'Dhuhr',
        asr      : 'Asr',
        sunset   : 'Sunset',
        maghrib  : 'Maghrib',
        isha     : 'Isha',
        midnight : 'Midnight'
    },


    // Calculation Methods
    methods = {
        MWL: {
            name: 'Muslim World League',
            params: { fajr: 18, isha: 17 } },
        ISNA: {
            name: 'Islamic Society of North America (ISNA)',
            params: { fajr: 15, isha: 15 } },
        Egypt: {
            name: 'Egyptian General Authority of Survey',
            params: { fajr: 19.5, isha: 17.5 } },
        Makkah: {
            name: 'Umm Al-Qura University, Makkah',
            params: { fajr: 18.5, isha: '90 min' } },  // fajr was 19 degrees before 1430 hijri
        Karachi: {
            name: 'University of Islamic Sciences, Karachi',
            params: { fajr: 18, isha: 18 } },
        Tehran: {
            name: 'Institute of Geophysics, University of Tehran',
            params: { fajr: 17.7, isha: 14, maghrib: 4.5, midnight: 'Jafari' } },  // isha is not explicitly specified in this method
        Jafari: {
            name: 'Shia Ithna-Ashari, Leva Institute, Qum',
            params: { fajr: 16, isha: 14, maghrib: 4, midnight: 'Jafari' } }
    },


    // Default Parameters in Calculation Methods
    defaultParams = {
        maghrib: '0 min', midnight: 'Standard'

    },
 
 
    //----------------------- Parameter Values ----------------------
    /*
    
    // Asr Juristic Methods
    asrJuristics = [ 
        'Standard',    // Shafi`i, Maliki, Ja`fari, Hanbali
        'Hanafi'       // Hanafi
    ],


    // Midnight Mode
    midnightMethods = [ 
        'Standard',    // Mid Sunset to Sunrise
        'Jafari'       // Mid Sunset to Fajr
    ],


    // Adjust Methods for Higher Latitudes
    highLatMethods = [
        'NightMiddle', // middle of night
        'AngleBased',  // angle/60th of night
        'OneSeventh',  // 1/7th of night
        'None'         // No adjustment
    ],


    // Time Formats
    timeFormats = [
        '24h',         // 24-hour format
        '12h',         // 12-hour format
        '12hNS',       // 12-hour format with no suffix
        'Float'        // floating point number 
    ],
    */  


    //---------------------- Default Settings --------------------
    
    calcMethod = 'MWL',

    // do not change anything here; use adjust method instead
    setting = {  
        imsak    : '10 min',
        dhuhr    : '0 min',  
        asr      : 'Standard',
        highLats : 'NightMiddle'
    },

    timeFormat = '24h',
    timeSuffixes = ['am', 'pm'],
    invalidTime =  '-----',

    numIterations = 1,
    offset = {},


    //----------------------- Local Variables ---------------------

    lat, lng, elv,       // coordinates
    timeZone, jDate;     // time variables
    

    //---------------------- Initialization -----------------------
    
    
    // set methods defaults
    var defParams = defaultParams;
    for (var i in methods) {
        var params = methods[i].params;
        for (var j in defParams)
            if ((typeof(params[j]) == 'undefined'))
                params[j] = defParams[j];
    };

    // initialize settings
    calcMethod = methods[method] ? method : calcMethod;
    var params = methods[calcMethod].params;
    for (var id in params)
        setting[id] = params[id];

    // init time offsets
    for (var i in timeNames)
        offset[i] = 0;

        
    
    //----------------------- Public Functions ------------------------
    return {

    
    // set calculation method 
    setMethod: function(method) {
        if (methods[method]) {
            this.adjust(methods[method].params);
            calcMethod = method;
        }
    },


    // set calculating parameters
    adjust: function(params) {
        for (var id in params)
            setting[id] = params[id];
    },


    // set time offsets
    tune: function(timeOffsets) {
        for (var i in timeOffsets)
            offset[i] = timeOffsets[i];
    },


    // get current calculation method
    getMethod: function() { return calcMethod; },

    // get current setting
    getSetting: function() { return setting; },

    // get current time offsets
    getOffsets: function() { return offset; },

    // get default calc parametrs
    getDefaults: function() { return methods; },


    // return prayer times for a given date
    getTimes: function(date, coords, timezone, dst, format) {
        lat = 1* coords[0];
        lng = 1* coords[1]; 
        elv = coords[2] ? 1* coords[2] : 0;
        timeFormat = format || timeFormat;
        if (date.constructor === Date)
            date = [date.getFullYear(), date.getMonth()+ 1, date.getDate()];
        if (typeof(timezone) == 'undefined' || timezone == 'auto')
            timezone = this.getTimeZone(date);
        if (typeof(dst) == 'undefined' || dst == 'auto') 
            dst = this.getDst(date);
        timeZone = 1* timezone+ (1* dst ? 1 : 0);
        jDate = this.julian(date[0], date[1], date[2])- lng/ (15* 24);
        
        return this.computeTimes();
    },


    // convert float time to the given format (see timeFormats)
    getFormattedTime: function(time, format, suffixes) {
        if (isNaN(time))
            return invalidTime;
        if (format == 'Float') return time;
        suffixes = suffixes || timeSuffixes;

        time = DMath.fixHour(time+ 0.5/ 60);  // add 0.5 minutes to round
        var hours = Math.floor(time); 
        var minutes = Math.floor((time- hours)* 60);
        var suffix = (format == '12h') ? suffixes[hours < 12 ? 0 : 1] : '';
        var hour = (format == '24h') ? this.twoDigitsFormat(hours) : ((hours+ 12 -1)% 12+ 1);
        return hour+ ':'+ this.twoDigitsFormat(minutes)+ (suffix ? ' '+ suffix : '');
    },


    //---------------------- Calculation Functions -----------------------


    // compute mid-day time
    midDay: function(time) {
        var eqt = this.sunPosition(jDate+ time).equation;
        var noon = DMath.fixHour(12- eqt);
        return noon;
    },


    // compute the time at which sun reaches a specific angle below horizon
    sunAngleTime: function(angle, time, direction) {
        var decl = this.sunPosition(jDate+ time).declination;
        var noon = this.midDay(time);
        var t = 1/15* DMath.arccos((-DMath.sin(angle)- DMath.sin(decl)* DMath.sin(lat))/ 
                (DMath.cos(decl)* DMath.cos(lat)));
        return noon+ (direction == 'ccw' ? -t : t);
    },


    // compute asr time 
    asrTime: function(factor, time) { 
        var decl = this.sunPosition(jDate+ time).declination;
        var angle = -DMath.arccot(factor+ DMath.tan(Math.abs(lat- decl)));
        return this.sunAngleTime(angle, time);
    },


    // compute declination angle of sun and equation of time
    // Ref: http://aa.usno.navy.mil/faq/docs/SunApprox.php
    sunPosition: function(jd) {
        var D = jd - 2451545.0;
        var g = DMath.fixAngle(357.529 + 0.98560028* D);
        var q = DMath.fixAngle(280.459 + 0.98564736* D);
        var L = DMath.fixAngle(q + 1.915* DMath.sin(g) + 0.020* DMath.sin(2*g));

        var R = 1.00014 - 0.01671* DMath.cos(g) - 0.00014* DMath.cos(2*g);
        var e = 23.439 - 0.00000036* D;

        var RA = DMath.arctan2(DMath.cos(e)* DMath.sin(L), DMath.cos(L))/ 15;
        var eqt = q/15 - DMath.fixHour(RA);
        var decl = DMath.arcsin(DMath.sin(e)* DMath.sin(L));

        return {declination: decl, equation: eqt};
    },


    // convert Gregorian date to Julian day
    // Ref: Astronomical Algorithms by Jean Meeus
    julian: function(year, month, day) {
        if (month <= 2) {
            year -= 1;
            month += 12;
        };
        var A = Math.floor(year/ 100);
        var B = 2- A+ Math.floor(A/ 4);

        var JD = Math.floor(365.25* (year+ 4716))+ Math.floor(30.6001* (month+ 1))+ day+ B- 1524.5;
        return JD;
    },

    
    //---------------------- Compute Prayer Times -----------------------


    // compute prayer times at given julian date
    computePrayerTimes: function(times) {
        times = this.dayPortion(times);
        var params  = setting;
        
        var imsak   = this.sunAngleTime(this.eval(params.imsak), times.imsak, 'ccw');
        var fajr    = this.sunAngleTime(this.eval(params.fajr), times.fajr, 'ccw');
        var sunrise = this.sunAngleTime(this.riseSetAngle(), times.sunrise, 'ccw');  
        var dhuhr   = this.midDay(times.dhuhr);
        var asr     = this.asrTime(this.asrFactor(params.asr), times.asr);
        var sunset  = this.sunAngleTime(this.riseSetAngle(), times.sunset);;
        var maghrib = this.sunAngleTime(this.eval(params.maghrib), times.maghrib);
        var isha    = this.sunAngleTime(this.eval(params.isha), times.isha);

        return {
            imsak: imsak, fajr: fajr, sunrise: sunrise, dhuhr: dhuhr, 
            asr: asr, sunset: sunset, maghrib: maghrib, isha: isha
        };
    },


    // compute prayer times 
    computeTimes: function() {
        // default times
        var times = { 
            imsak: 5, fajr: 5, sunrise: 6, dhuhr: 12, 
            asr: 13, sunset: 18, maghrib: 18, isha: 18
        };

        // main iterations
        for (var i=1 ; i<=numIterations ; i++) 
            times = this.computePrayerTimes(times);

        times = this.adjustTimes(times);
        
        // add midnight time
        times.midnight = (setting.midnight == 'Jafari') ? 
                times.sunset+ this.timeDiff(times.sunset, times.fajr)/ 2 :
                times.sunset+ this.timeDiff(times.sunset, times.sunrise)/ 2;

        times = this.tuneTimes(times);
        return this.modifyFormats(times);
    },


    // adjust times 
    adjustTimes: function(times) {
        var params = setting;
        for (var i in times)
            times[i] += timeZone- lng/ 15;
            
        if (params.highLats != 'None')
            times = this.adjustHighLats(times);
            
        if (this.isMin(params.imsak))
            times.imsak = times.fajr- this.eval(params.imsak)/ 60;
        if (this.isMin(params.maghrib))
            times.maghrib = times.sunset+ this.eval(params.maghrib)/ 60;
        if (this.isMin(params.isha))
            times.isha = times.maghrib+ this.eval(params.isha)/ 60;
        times.dhuhr += this.eval(params.dhuhr)/ 60; 

        return times;
    },


    // get asr shadow factor
    asrFactor: function(asrParam) {
        var factor = {Standard: 1, Hanafi: 2}[asrParam];
        return factor || this.eval(asrParam);
    },


    // return sun angle for sunset/sunrise
    riseSetAngle: function() {
        //var earthRad = 6371009; // in meters
        //var angle = DMath.arccos(earthRad/(earthRad+ elv));
        var angle = 0.0347* Math.sqrt(elv); // an approximation
        return 0.833+ angle;
    },


    // apply offsets to the times
    tuneTimes: function(times) {
        for (var i in times)
            times[i] += offset[i]/ 60; 
        return times;
    },


    // convert times to given time format
    modifyFormats: function(times) {
        for (var i in times)
            times[i] = this.getFormattedTime(times[i], timeFormat); 
        return times;
    },


    // adjust times for locations in higher latitudes
    adjustHighLats: function(times) {
        var params = setting;
        var nightTime = this.timeDiff(times.sunset, times.sunrise); 

        times.imsak = this.adjustHLTime(times.imsak, times.sunrise, this.eval(params.imsak), nightTime, 'ccw');
        times.fajr  = this.adjustHLTime(times.fajr, times.sunrise, this.eval(params.fajr), nightTime, 'ccw');
        times.isha  = this.adjustHLTime(times.isha, times.sunset, this.eval(params.isha), nightTime);
        times.maghrib = this.adjustHLTime(times.maghrib, times.sunset, this.eval(params.maghrib), nightTime);
        
        return times;
    },

    
    // adjust a time for higher latitudes
    adjustHLTime: function(time, base, angle, night, direction) {
        var portion = this.nightPortion(angle, night);
        var timeDiff = (direction == 'ccw') ? 
            this.timeDiff(time, base):
            this.timeDiff(base, time);
        if (isNaN(time) || timeDiff > portion) 
            time = base+ (direction == 'ccw' ? -portion : portion);
        return time;
    },

    
    // the night portion used for adjusting times in higher latitudes
    nightPortion: function(angle, night) {
        var method = setting.highLats;
        var portion = 1/2 // MidNight
        if (method == 'AngleBased')
            portion = 1/60* angle;
        if (method == 'OneSeventh')
            portion = 1/7;
        return portion* night;
    },


    // convert hours to day portions 
    dayPortion: function(times) {
        for (var i in times)
            times[i] /= 24;
        return times;
    },


    //---------------------- Time Zone Functions -----------------------


    // get local time zone
    getTimeZone: function(date) {
        var year = date[0];
        var t1 = this.gmtOffset([year, 0, 1]);
        var t2 = this.gmtOffset([year, 6, 1]);
        return Math.min(t1, t2);
    },

    
    // get daylight saving for a given date
    getDst: function(date) {
        return 1* (this.gmtOffset(date) != this.getTimeZone(date));
    },


    // GMT offset for a given date
    gmtOffset: function(date) {
        var localDate = new Date(date[0], date[1]- 1, date[2], 12, 0, 0, 0);
        var GMTString = localDate.toGMTString();
        var GMTDate = new Date(GMTString.substring(0, GMTString.lastIndexOf(' ')- 1));
        var hoursDiff = (localDate- GMTDate) / (1000* 60* 60);
        return hoursDiff;
    },

    
    //---------------------- Misc Functions -----------------------

    // convert given string into a number
    eval: function(str) {
        return 1* (str+ '').split(/[^0-9.+-]/)[0];
    },


    // detect if input contains 'min'
    isMin: function(arg) {
        return (arg+ '').indexOf('min') != -1;
    },


    // compute the difference between two times 
    timeDiff: function(time1, time2) {
        return DMath.fixHour(time2- time1);
    },


    // add a leading 0 if necessary
    twoDigitsFormat: function(num) {
        return (num <10) ? '0'+ num : num;
    }
    
}}



//---------------------- Degree-Based Math Class -----------------------


var DMath = {

    dtr: function(d) { return (d * Math.PI) / 180.0; },
    rtd: function(r) { return (r * 180.0) / Math.PI; },

    sin: function(d) { return Math.sin(this.dtr(d)); },
    cos: function(d) { return Math.cos(this.dtr(d)); },
    tan: function(d) { return Math.tan(this.dtr(d)); },

    arcsin: function(d) { return this.rtd(Math.asin(d)); },
    arccos: function(d) { return this.rtd(Math.acos(d)); },
    arctan: function(d) { return this.rtd(Math.atan(d)); },

    arccot: function(x) { return this.rtd(Math.atan(1/x)); },
    arctan2: function(y, x) { return this.rtd(Math.atan2(y, x)); },

    fixAngle: function(a) { return this.fix(a, 360); },
    fixHour:  function(a) { return this.fix(a, 24 ); },

    fix: function(a, b) { 
        a = a- b* (Math.floor(a/ b));
        return (a < 0) ? a+ b : a;
    }
}


//---------------------- Init Object -----------------------


var prayTimes = new PrayTimes();