import numpy as np


def convert_int_to_freq(spec_ind, spec_height, min_freq, max_freq):
    spec_ind = spec_height-spec_ind
    return round((spec_ind / float(spec_height)) * (max_freq - min_freq) + min_freq, 2)


def extract_spec_slices(spec, pred_nms, params):
    """
    Extracts spectrogram slices from spectrogram based on detected call locations.
    """

    x_pos          = pred_nms['x_pos']
    y_pos          = pred_nms['y_pos']
    bb_width       = pred_nms['bb_width']
    bb_height      = pred_nms['bb_height']
    slices    = []

    # add 20% padding either side of call
    pad          = bb_width*0.2
    x_pos_pad    = x_pos - pad
    bb_width_pad = bb_width + 2*pad

    for ff in range(len(pred_nms['det_probs'])):
        x_start = int(np.maximum(0, x_pos_pad[ff]))
        x_end   = int(np.minimum(spec.shape[1]-1, np.round(x_pos_pad[ff] + bb_width_pad[ff])))
        slices.append(spec[:, x_start:x_end].astype(np.float16))
    return slices


def get_feature_names():
    feature_names  = ['duration', 'low_freq_bb', 'high_freq_bb', 'bandwidth',
                     'max_power_bb', 'max_power', 'max_power_first',
                     'max_power_second', 'call_interval']
    return feature_names


def get_feats(spec, pred_nms, params):
    """
    Extracts features from spectrogram based on detected call locations.
    Condsider re-extracting spectrogram for this to get better temporal resolution.

    For more possible features check out:
    https://github.com/YvesBas/Tadarida-D/blob/master/Manual_Tadarida-D.odt
    """

    x_pos          = pred_nms['x_pos']
    y_pos          = pred_nms['y_pos']
    bb_width       = pred_nms['bb_width']
    bb_height      = pred_nms['bb_height']

    feature_names  = get_feature_names()
    num_detections = len(pred_nms['det_probs'])
    features       = np.ones((num_detections, len(feature_names)), dtype=np.float32)*-1

    for ff in range(num_detections):
        x_start = int(np.maximum(0, x_pos[ff]))
        x_end   = int(np.minimum(spec.shape[1]-1, np.round(x_pos[ff] + bb_width[ff])))
        # y low is the lowest freq but it will have a higher value due to array starting at 0 at top
        y_low   = int(np.minimum(spec.shape[0]-1, y_pos[ff]))
        y_high  = int(np.maximum(0, np.round(y_pos[ff] - bb_height[ff])))
        spec_slice = spec[:, x_start:x_end]

        if spec_slice.shape[1] > 1:
            features[ff, 0] = round(pred_nms['end_times'][ff] - pred_nms['start_times'][ff], 5)
            features[ff, 1] = int(pred_nms['low_freqs'][ff])
            features[ff, 2] = int(pred_nms['high_freqs'][ff])
            features[ff, 3] = int(pred_nms['high_freqs'][ff] - pred_nms['low_freqs'][ff])
            features[ff, 4] = int(convert_int_to_freq(y_high+spec_slice[y_high:y_low, :].sum(1).argmax(),
                                       spec.shape[0], params['min_freq'], params['max_freq']))
            features[ff, 5] = int(convert_int_to_freq(spec_slice.sum(1).argmax(),
                                       spec.shape[0], params['min_freq'], params['max_freq']))
            hlf_val = spec_slice.shape[1]//2

            features[ff, 6] = int(convert_int_to_freq(spec_slice[:, :hlf_val].sum(1).argmax(),
                                       spec.shape[0], params['min_freq'], params['max_freq']))
            features[ff, 7] = int(convert_int_to_freq(spec_slice[:, hlf_val:].sum(1).argmax(),
                                       spec.shape[0], params['min_freq'], params['max_freq']))

            if ff > 0:
                features[ff, 8] = round(pred_nms['start_times'][ff] - pred_nms['start_times'][ff-1], 5)

    return features