Изворни код странице Модул:WeatherBox

w = {};
math_mod = require( "Module:Math" );
wbc = require( "Module:WeatherBoxColors" );


function checkFlag( flag )
    if flag == nil then
        return nil;
    elseif type( flag ) == 'boolean' then
        return flag;
    elseif type( flag ) == 'string' then
        flag = mw.ustring.lower(flag);
        if flag == '0' or flag == 'false' or
                flag == '' or flag == 'no' or
                flag == 'n' then
            return false;
        else
            return true;
        end
    else
        return error( 'Тип flag-а није валидан' );
    end
end


function w.buildRow( frame )
    local mode = (mw.ustring.lower(frame.args.mode) or 'basic');
    local group_name = frame.args.group_name;
    local first_value_string, second_value_string;
    local first_value_number, second_value_number, color_values;
    local color_scheme = frame.args.color_scheme or 't';
    local scale_factor = math_mod._cleanNumber( frame.args.scale_factor) or 1;
    local date_mode = checkFlag( frame.args.date_mode or false );
    local label = frame.args.label or '';
    local annual_mode = (frame.args.annual_mode or 'avg'):lower();
    local include_space = checkFlag( frame.args.include_space or true );
    local second_line = checkFlag( frame.args.second_line ) or false;
    local prefer_cm = checkFlag( frame.args.prefer_cm ) or false;
    local result;


    local pframe = frame:getParent();


    local imperial_first = checkFlag( frame.args['imperial first'] );
    if imperial_first == nil then imperial_first = checkFlag( pframe.args['imperial first'] ); end
    local tr_imperial_first = checkFlag( frame.args['прво империјални'] );
    if tr_imperial_first == nil then tr_imperial_first = checkFlag( pframe.args['прво империјални'] ); end
        
    local metric_first = checkFlag( frame.args['metric first'] );
    if metric_first == nil then metric_first = checkFlag( pframe.args['metric first'] ); end
    local tr_metric_first = checkFlag( frame.args['прво метрички'] );
    if tr_metric_first == nil then tr_metric_first = checkFlag( pframe.args['прво метрички'] ); end

    local single_line = checkFlag( frame.args['single line'] );
    if single_line == nil then single_line = checkFlag( pframe.args['single line'] ); end
    local tr_single_line = checkFlag( frame.args['један ред'] );
    if tr_single_line == nil then tr_single_line = checkFlag( pframe.args['један ред'] ); end
    local tr_single_line = checkFlag( frame.args['заграде'] );
    if tr_single_line == nil then tr_single_line = checkFlag( pframe.args['заграде'] ); end

    local double_line = checkFlag( frame.args['double line'] );
    if double_line == nil then double_line = checkFlag( pframe.args['double line'] ); end
    local tr_double_line = checkFlag( frame.args['два реда'] );
    if tr_double_line == nil then tr_double_line = checkFlag( pframe.args['два реда'] ); end
    local tr_double_line = checkFlag( frame.args['засебно'] );
    if tr_double_line == nil then tr_double_line = checkFlag( pframe.args['засебно'] ); end

    if metric_first == nil and imperial_first ~= nil then
        metric_first = not imperial_first;
    else
        metric_first = true;
    end
    if tr_metric_first == nil and tr_imperial_first ~= nil then
        tr_metric_first = not tr_imperial_first;
    else
        tr_metric_first = true;
    end
    if metric_first == nil and tr_imperial_first ~= nil then
        metric_first = not tr_imperial_first;
    else
        metric_first = true;
    end
    if tr_metric_first == nil and imperial_first ~= nil then
        tr_metric_first = not imperial_first;
    else
        tr_metric_first = true;
    end


    if mode == 'basic' then
        first_value_string, first_value_number = getInputs( pframe, group_name,
            nil, nil, nil, include_space );
        second_value_string = nil;
        second_value_number = nil;
    elseif mode == 'tr_basic' then
        first_value_string, first_value_number = getInputs( pframe, group_name,
            nil, {'tr_mon_mode'}, nil, include_space );
        second_value_string = nil;
        second_value_number = nil;
    elseif mode == 'temperature' then
        first_value_string, first_value_number = getInputs( pframe, group_name,
            {'C'}, nil, nil, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name,
            {'F'}, nil, nil, include_space );
        first_value_string, first_value_number, second_value_string, second_value_number =
            reconcileTemperature( first_value_string, first_value_number, 
                second_value_string, second_value_number )
    elseif mode == 'tr_temperature' then
        first_value_string, first_value_number = getInputs( pframe, group_name,
            {'C'}, {'tr_mon_mode'}, nil, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name,
            {'F'}, {'tr_mon_mode'}, nil, include_space );
        first_value_string, first_value_number, second_value_string, second_value_number =
            reconcileTemperature( first_value_string, first_value_number,
                second_value_string, second_value_number )
    elseif mode == 'tr_temperature_old' then
        first_value_string, first_value_number = getInputs( pframe, group_name,
            {''}, nil, {'tr_mon_mode_old'}, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name,
            {''}, nil, nil, include_space );
        first_value_string, first_value_number, second_value_string, second_value_number =
            reconcileTemperature( first_value_string, first_value_number,
                second_value_string, second_value_number )
    elseif mode == 'precipitation' then
        first_value_string, first_value_number, variant = getInputs( pframe, group_name,
            {'cm', 'mm'}, nil, nil, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name,
            {'inch'}, nil, nil, include_space );
        first_value_string, first_value_number, second_value_string, second_value_number,
            variant =
            reconcilePrecipitation( first_value_string, first_value_number,
                second_value_string, second_value_number, variant, prefer_cm )
    elseif mode == 'tr_precipitation' then
        first_value_string, first_value_number, variant = getInputs( pframe, group_name,
            {'cm', 'mm'}, {'tr_mon_mode'}, nil, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name,
            {'in'}, {'tr_mon_mode'}, nil, include_space );
        first_value_string, first_value_number, second_value_string, second_value_number,
            variant =
            reconcilePrecipitation( first_value_string, first_value_number,
                second_value_string, second_value_number, variant, prefer_cm )
    elseif mode == 'tr_precipitation_old' then
        first_value_string, first_value_number, variant = getInputs( pframe, group_name,
            {'', ''}, nil, {'tr_mon_mode_old'}, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name,
            {''}, nil, nil, include_space );
        first_value_string, first_value_number, second_value_string, second_value_number,
            variant =
            reconcilePrecipitation( first_value_string, first_value_number,
                second_value_string, second_value_number, variant, prefer_cm )
    else
        error( 'Тражени мод није препознат' );
    end
    
    local good = false;
    for i = 1,13 do
        if first_value_string[i] ~= nil and first_value_string[i] ~= '' then
            good = true;
            break;
        end
    end
    if not good then
        return '';
    end


    if first_value_string[13] == nil or first_value_string[13] == '' then
        first_value_string[13], first_value_number[13] = getAnnualValue( first_value_number, annual_mode );
    end
    if second_value_string ~= nil then
        if second_value_string[13] == nil or second_value_string[13] == '' then
            second_value_string[13], second_value_number[13] = getAnnualValue( second_value_number, annual_mode );
        end
        if mode == 'precipitation' or mode == 'tr_precipitation' then
            for i = 1,12 do
                if variant[i] ~= 0 then
                    variant[13] = variant[i];
                    break;
                end
            end
        end
    end


    color_scheme = wbc.interpret_color_code( color_scheme );

    color_values = {};
    month_adj = { 31/30, 28/30, 31/30, 1, 31/30, 1, 
        31/30, 31/30, 1, 31/30, 1, 31/30, 12.175 };
    local adj;
    for i = 1,13 do
        if first_value_number[i] ~= nil and first_value_number[i] ~= -9999 then
            adj = scale_factor;
            if date_mode then
                adj = adj / month_adj[i];
            end
            if mode == 'precipitation' or mode == 'tr_precipitation' then
                if variant[i] == 1 then
                    adj = adj * 10;
                end
            end
            table.insert( color_values, color_scheme( first_value_number[i] * adj ) );
        else
            table.insert( color_values, color_scheme( nil ) );
        end
    end


    local lang = mw.getContentLanguage();
    for i = 1,13 do
        if first_value_number[i] ~= nil and first_value_number[i] ~= -9999 then
            if math.abs(first_value_number[i]) >= 1000 then
                first_value_string[i] = lang:formatNum( math.abs(first_value_number[i]) );
                if first_value_number[i] < 0 then
                    first_value_string[i] = '−' .. first_value_string[i];
                end
            elseif first_value_number[i] < 0 then
                first_value_string[i] = '−' .. first_value_string[i]:sub(2);
            end
        end
        if second_value_number ~= nil then
            if second_value_number[i] ~= nil and second_value_number[i] ~= -9999 then
                if math.abs(first_value_number[i]) >= 1000 then
                    second_value_string[i] = lang:formatNum( math.abs(second_value_number[i]) );
                    if second_value_number[i] < 0 then
                        second_value_string[i] = '−' .. second_value_string[i];
                    end
                elseif second_value_number[i] < 0 then
                    second_value_string[i] = '−' .. second_value_string[i]:sub(2);
                end
            end
        end
    end


    if (imperial_first or tr_imperial_first) and second_value_string ~= nil then
        local t = first_value_string;
        first_value_string = second_value_string;
        second_value_string = t;
    end
    
    if double_line or tr_double_line or tr_double_line2 then
        if second_line and second_value_string ~= nil then
            first_value_string = second_value_string;
        end
        second_value_string = nil;
    end


    return makeLine( label, first_value_string, second_value_string, color_values, color_scheme );
end


function makeLine( label, first_value_string, second_value_string, color_values, color_scheme )
    local result, color_str, value_str;
    
    result = {'|- style="text-align: center;"\n! style="height: 16px;" | ', label,  "\n"}
    for i = 1,13 do
        color_str = color_values[i];

        if i == 13 then
            table.insert( result, table.concat( {'|style="', color_str, ' border-left-width:medium" | '} ) );
        else
            table.insert( result, table.concat( {'|style="', color_str, '" | '} ) );
        end

        value_str = first_value_string[i]:gsub('%.',',');
        if value_str ~= '' and value_str ~= nil then
            table.insert( result, value_str );
            if second_value_string ~= nil then
                value_str = second_value_string[i]:gsub('%.',',');
                if value_str ~= '' and value_str ~= nil then
                    table.insert( result, "<br /> (" .. value_str .. ")" );
                end
            end
        else
            table.insert( result, '—' );
        end
    
        table.insert( result, "\n" );
    end
    
    return table.concat( result );
end


function getInputs( frame, group_name, suffix, tr_mon_mode, tr_mon_mode_old, include_space )
    local month_names;
    if tr_mon_mode_old ~= nil then
        month_names = { 'Јан', 'Феб', 'Мар', 'Апр', 'Мај', 'Јун',
                        'Јул', 'Авг', 'Сеп', 'Окт', 'Нов', 'Дец', 'Год' };
    elseif tr_mon_mode ~= nil then
        month_names = { 'јан', 'феб', 'мар', 'апр', 'мај', 'јун',
                        'јул', 'авг', 'сеп', 'окт', 'нов', 'дец', 'год' };
    else
        month_names = { 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
                        'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'year' };
    end

    local str, str2, val;
    
    local output_string = {};
    local output_value = {};
    local variant = {};
    if suffix == nil then
        for _, mon in ipairs( month_names ) do
            if include_space then
                if tr_mon_mode_old ~= nil then
                    str = ( frame.args[ mon .. '_' .. group_name ] );
                else
                    str = ( frame.args[ mon .. ' ' .. group_name ] );
                end
            else
                    str = ( frame.args[ mon .. group_name ] );
            end
            if str ~= nil and str ~= '' then
                val, str2 = math_mod._cleanNumber( str:gsub(',','%.') );
            else
                val, str2 = math_mod._cleanNumber( str );
            end
            if val ~= nil then
                table.insert( output_string, str2 );
                table.insert( output_value, val );
            else
                table.insert( output_string, str );
                table.insert( output_value, -9999 );
            end
        end
    else
        local updated = false;
        for _, mon in ipairs( month_names ) do
            updated = false;
            for i, suf in ipairs( suffix ) do
                if include_space then
                    if tr_mon_mode_old ~= nil then
                        str = frame.args[ mon .. '_' .. group_name ];
                    else
                        str = frame.args[ mon .. ' ' .. group_name .. ' ' .. suf ];
                    end
                else
                        str = frame.args[ mon .. group_name .. ' ' .. suf ];
                end
                if str ~= nil and str ~= '' then
                    val, str2 = math_mod._cleanNumber( str:gsub(',','.') );
                    if val ~= nil then
                        table.insert( output_string, str2 );
                        table.insert( output_value, val );
                    else
                        table.insert( output_string, str );
                        table.insert( output_value, -9999 );
                    end
                    table.insert( variant, i );
                    updated = true;
                    break;
                end
            end
            if not updated then
                table.insert( output_string, '' );
                table.insert( output_value, -9999 );
                table.insert( variant, 0 );
            end
        end
    end
    
    return output_string, output_value, variant;
end


function getAnnualValue( values, mode )
    local total = 0;
    local val = 0;
    
    if mode == 'avg' or mode == 'sum' then
        local p1, p2;
        p1 = 0;
        for i = 1, 12 do
            val = values[i];
            if val == -9999 then
                return '', -9999;
            end
            
            p2 = math_mod._precision( val );
            if p2 > p1 then
                p1 = p2;
            end
            
            total = total + val;
        end
        if mode == 'avg' then
            total = math_mod._round( total / 12, p1 + 1 );
        end
        return tostring( total ), total;
    elseif mode == 'min' then
        local min_val = nil;
        for i = 1, 12 do
            val = values[i];
            if val ~= -9999 then
                if min_val == nil or val < min_val then
                    min_val = val;
                end
            end
        end
        return tostring( min_val ), min_val;
    elseif mode == 'max' then
        local max_val = nil;
        for i = 1, 12 do
            val = values[i];
            if val ~= -9999 then
                if max_val == nil or val > max_val then
                    max_val = val;
                end
            end
        end
        return tostring(max_val), max_val;
    else
        error( 'Непрепознат годишњи мод' );
    end
end


function reconcileTemperature( C_degree_strings, C_degree_values, F_degree_strings, F_degree_values )
    local p;
    for i = 1,13 do
        if C_degree_strings[i] == '' then
            if F_degree_values[i] ~= -9999 then
                p = math.max( 0, math_mod._precision( F_degree_strings[i] ) );
                C_degree_values[i] = math_mod._round( (F_degree_values[i] - 32)*5/9, p );
                C_degree_strings[i] = tostring( C_degree_values[i] );
            end
        elseif F_degree_strings[i] == '' then
            if C_degree_values[i] ~= -9999 then
                p = math.max( 0, math_mod._precision( C_degree_strings[i] ) );
                F_degree_values[i] = math_mod._round( C_degree_values[i]*9/5 + 32, p );
                F_degree_strings[i] = tostring( F_degree_values[i] );
            end
        end
    end
    return C_degree_strings, C_degree_values, F_degree_strings, F_degree_values;
end

function reconcilePrecipitation( M_degree_strings, M_degree_values,
        I_degree_strings, I_degree_values, variant, prefer_cm )
    local p;
    
    local v_class = 0;
    for i = 1,13 do
        if variant[i] == 1 then
            v_class = 1;
        elseif variant[i] == 2 then
            v_class = 2;
        end
    end
    if v_class == 0 then
        if prefer_cm then
            v_class = 1;
        else
            v_class = 2;
        end
    end
    for i = 1,13 do
        if M_degree_strings[i] == '' then
            if I_degree_values[i] ~= -9999 then
                if v_class == 1 then
                    p = math.max( 0, math_mod._precision( I_degree_strings[i] ) );
                    M_degree_values[i] = math_mod._round( I_degree_values[i]*2.54, p );
                    variant[i] = v_class;
                else
                    p = math.max( 0, math_mod._precision( I_degree_strings[i] ) ) - 1;
                    M_degree_values[i] = math_mod._round( I_degree_values[i]*25.4, p );
                    variant[i] = v_class;
                end
                M_degree_strings[i] = tostring( M_degree_values[i] );
            end
        elseif I_degree_strings[i] == '' then
            if M_degree_values[i] ~= -9999 then
                if variant[i] == 1 then
                    p = math.max( 0, math_mod._precision( M_degree_strings[i] ) ) + 1;
                    I_degree_values[i] = M_degree_values[i]/2.54;
                else
                    p = math.max( 0, math_mod._precision( M_degree_strings[i] ) ) + 2;
                    I_degree_values[i] = M_degree_values[i]/25.4;
                end
                I_degree_values[i] = math_mod._round( I_degree_values[i], p );
                I_degree_strings[i] = tostring( I_degree_values[i] );
            end
        end
    end
    return M_degree_strings, M_degree_values, I_degree_strings, I_degree_values, variant;
end


return w;