/*
 * Copyright (C) 2016 "IoT.bzh"
 * Author Fulup Ar Foll <fulup@iot.bzh>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 * references: 
 *   alsa-util/amixer.c + alsa-lib/simple.c
 *   snd_tlv_convert_from_dB
 *   nt snd_tlv_convert_to_dB
 *   snd_tlv_get_dB_range
 */

#define _GNU_SOURCE  // needed for vasprintf
#include <math.h>
#include "hal-interface.h"


typedef enum {  
   NORMALIZE_NONE=0,  
   NORMALIZE_DB_LINEAR,
   NORMALIZE_DB_MATH,           
   NORMALIZE_LINEAR,           
} enumRandeModeDB_T;


// Return Value express from 0-100%
STATIC int dbNormalizeVal (enumRandeModeDB_T normaliseMode, const alsaHalDBscaleT *dbscale, int value) {
    double normalized, min_norm;

    // To get real DB from TLV DB values should be divided by 100
    switch (normaliseMode) {
        case NORMALIZE_DB_LINEAR:
            normalized = ((double)(value-dbscale->min)/(double)(dbscale->max-dbscale->min));
            break;
            
        case  NORMALIZE_DB_MATH:
            normalized = exp10((double)(value - dbscale->max) / 6000.0);
            if (dbscale->min != SND_CTL_TLV_DB_GAIN_MUTE) {
                    min_norm = exp10((double)(dbscale->min - dbscale->max) / 20);
                    normalized = (normalized - min_norm) / (1 - min_norm);
            }
            
            break;
            
        default:
            normalized=0;            
    }
    
    return (int)round(normalized*100);   
}

// HAL normalise volume values to 0-100%
PUBLIC json_object *volumeNormalise(ActionSetGetT action, const alsaHalCtlMapT *halCtls,  json_object *valuesJ) {
    enumRandeModeDB_T useNormalizeDB;
    int length;

    // If Integer look for DBscale
    if (halCtls->type == SND_CTL_ELEM_TYPE_INTEGER) {
    
        // If not valid db_scale let's use raw_scale
        if (!halCtls->dbscale || (halCtls->dbscale->min >= halCtls->dbscale->max)) {
       
        // dbscale is invalid let's try raw range
        if (halCtls->minval >= halCtls->maxval) goto ExitOnError;
        
        // Use Raw Scale Model
        useNormalizeDB= NORMALIZE_LINEAR;
        
        } else { // db_scale looks OK let's use it
            if ((halCtls->dbscale->max - halCtls->dbscale->min) <= MAX_LINEAR_DB_SCALE * 100) useNormalizeDB= NORMALIZE_DB_LINEAR;
            else useNormalizeDB = NORMALIZE_LINEAR; // Fulup not sure how to handle this useNormalizeDB=NORMALIZE_DB_MATH;            
        }
    } else useNormalizeDB= NORMALIZE_NONE;
    
    
    // loop on values to normalise
    enum json_type jtype=json_object_get_type(valuesJ);
    if (jtype == json_type_array) length = json_object_array_length(valuesJ);   
    else length = 1;
    
    json_object *normalisedJ= json_object_new_array();
    for (int idx=0; idx < length; idx++) {
        int value;
        
        if (jtype == json_type_array) {
            json_object *valueJ = json_object_array_get_idx (valuesJ, idx);
            value = json_object_get_int(valueJ);
        } else {
            value = json_object_get_int(valuesJ);
        }
               
        // If Integer scale to 0/100
        if (halCtls->type == SND_CTL_ELEM_TYPE_INTEGER) {
            
            switch (action) {
                    
                case ACTION_GET:
                    switch (useNormalizeDB) {                            
                        case NORMALIZE_LINEAR:
                            value = 100* (value - halCtls->minval) / (halCtls->maxval - halCtls->minval);
                            break;
                        case NORMALIZE_DB_MATH: //ToBeDone
                            value = dbNormalizeVal (useNormalizeDB, halCtls->dbscale, value);
                            break;
                        case NORMALIZE_NONE: 
                        default:
                            value = value;
                    }
                    break;
                    
                case ACTION_SET:    
                    switch (useNormalizeDB) {                            
                        case NORMALIZE_LINEAR:
                            value = (value * (halCtls->maxval - halCtls->minval))/100;
                            break;
                        case NORMALIZE_DB_MATH: //ToBeDone
                            value = dbNormalizeVal (useNormalizeDB, halCtls->dbscale, value);
                            break;
                        case NORMALIZE_NONE: 
                        default:
                            value = value;
                    }
                    break;
                    
                default: 
                    AFB_NOTICE ("volumeNormalise: invalid action value=%d", (int)action);
                    goto ExitOnError;    
            }
        } 
        
        json_object_array_add(normalisedJ, json_object_new_int(value));  
    }
    
    return (normalisedJ);
    
  ExitOnError:
        return NULL;
}