#!/usr/bin/env python
# encoding: utf-8

from .on_score_column import score_to_mark, score_to_level


def compute_marks(df, score_max, rounding=lambda x: round(x, 2)):
    """Compute the mark for the dataframe

    apply score_to_mark to each row

    :param df: DataFrame with "score", "is_leveled" and "score_rate" columns.

    >>> import pandas as pd
    >>> d = {"Eleve":["E1"]*6 + ["E2"]*6,
    ...    "score_rate":[1]*2+[2]*2+[2]*2 + [1]*2+[2]*2+[2]*2,
    ...    "is_leveled":[0]*4+[1]*2 + [0]*4+[1]*2,
    ...    "score":[1, 0.33, 2, 1.5, 1, 3,   0.666, 1, 1.5, 1, 2, 3],
    ...    }
    >>> df = pd.DataFrame(d)
    >>> df
       Eleve  score_rate  is_leveled  score
    0     E1           1           0  1.000
    1     E1           1           0  0.330
    2     E1           2           0  2.000
    3     E1           2           0  1.500
    4     E1           2           1  1.000
    5     E1           2           1  3.000
    6     E2           1           0  0.666
    7     E2           1           0  1.000
    8     E2           2           0  1.500
    9     E2           2           0  1.000
    10    E2           2           1  2.000
    11    E2           2           1  3.000
    >>> compute_marks(df, 3)
    0     1.00
    1     0.33
    2     2.00
    3     1.50
    4     0.67
    5     2.00
    6     0.67
    7     1.00
    8     1.50
    9     1.00
    10    1.33
    11    2.00
    dtype: float64
    >>> from .on_value import round_half_point
    >>> compute_marks(df, 3, round_half_point)
    0     1.0
    1     0.5
    2     2.0
    3     1.5
    4     0.5
    5     2.0
    6     0.5
    7     1.0
    8     1.5
    9     1.0
    10    1.5
    11    2.0
    dtype: float64
    """
    return df[["score", "is_leveled", "score_rate"]].apply(
        lambda x: score_to_mark(x, score_max, rounding), axis=1
    )


def compute_level(df, level_max=3):
    """Compute level for the dataframe

    Applies score_to_level to each row

    :param df: DataFrame with "score", "is_leveled" and "score_rate" columns.
    :return: Columns with level

    >>> import pandas as pd
    >>> import numpy as np
    >>> d = {"Eleve":["E1"]*6 + ["E2"]*6,
    ...    "score_rate":[1]*2+[2]*2+[2]*2 + [1]*2+[2]*2+[2]*2,
    ...    "is_leveled":[0]*4+[1]*2 + [0]*4+[1]*2,
    ...    "score":[0, 0.33, 2, 1.5, 1, 3,   0.666, 1, 1.5, 1, 2, 3],
    ...    }
    >>> df = pd.DataFrame(d)
    >>> compute_level(df)
    0     0
    1     1
    2     3
    3     3
    4     1
    5     3
    6     2
    7     3
    8     3
    9     2
    10    2
    11    3
    dtype: int64
    """
    return df[["score", "is_leveled", "score_rate"]].apply(
        lambda x: score_to_level(x, level_max), axis=1
    )


def compute_normalized(df, rounding=lambda x: round(x, 2)):
    """Compute the normalized mark (Mark / score_rate)

    :param df: DataFrame with "Mark" and "score_rate" columns
    :return: column with normalized mark

    >>> import pandas as pd
    >>> d = {"Eleve":["E1"]*6 + ["E2"]*6,
    ...    "score_rate":[1]*2+[2]*2+[2]*2 + [1]*2+[2]*2+[2]*2,
    ...    "is_leveled":[0]*4+[1]*2 + [0]*4+[1]*2,
    ...    "score":[1, 0.33, 2, 1.5, 1, 3,   0.666, 1, 1.5, 1, 2, 3],
    ...    }
    >>> df = pd.DataFrame(d)
    >>> df["mark"] = compute_marks(df, 3)
    >>> compute_normalized(df)
    0     1.00
    1     0.33
    2     1.00
    3     0.75
    4     0.34
    5     1.00
    6     0.67
    7     1.00
    8     0.75
    9     0.50
    10    0.66
    11    1.00
    dtype: float64
    """
    return rounding(df["mark"] / df["score_rate"])


# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del