#!/usr/bin/env python
# -*- coding: utf-8 -*-

## Zadania

# ** zad. 0 **
# Sprawdź, czy masz zainstalowany pakiet ``pandas``. Jeżeli nie, zainstaluj go.
#
# ** zad. 2 (domowe) **
# Jest to zadanie złożone, składające się z kilku części. Całość będzie opierać się o dane zawarte w pliku *mieszkania.csv* i dotyczą cen mieszkań w Poznaniu kilka lat temu.
#  1, Otwórz plik ``task02.py``, który zawiera szkielet kodu, który będziemy rozwijać w tym zadaniu.
#  1. Napisz funkcje, która wczyta zestaw danych z pliku *mieszkania.csv* i zwróci obiekt typu *DataFrame*. Jeżeli wszystko zostało zrobione poprawnie, powinno się wyśtwietlić 5 pierwszych wierszy.
#  1. Uzupełnij funkcję ``most_common_room_number``, która zwróci jaka jest najpopularniejsza liczba pokoi w ogłoszeniach. Funkcji powinna zwrócić liczbę całkowitą.
#  1. Uzupełnij kod w funkcji ``cheapest_flats(dane, n)``, która wzróci *n* najtańszych ofert mieszkań. Wzrócony obiekt typu ``DataFrame``.
#  1. Napisz funkcje ``find_borough(desc)``, która przyjmuje 1 argument typu *string* i zwróci jedną z dzielnic zdefiniowaną w liście ``dzielnice``. Funkcja ma zwrócić pierwszą (wzgledem kolejności) nazwę dzielnicy, która jest zawarta w ``desc``. Jeżeli żadna nazwa nie została odnaleziona, zwróć *Inne*.
#  1. Dodaj kolumnę ``Borough``, która będzie zawierać informacje o dzielnicach i powstanie z kolumny ``Localization``. Wykorzystaj do tego funkcję ``find_borough``.
#  1. Uzupełnił funkcje ``write_plot``, która zapisze do pliku ``filename`` wykres słupkowy przedstawiający liczbę ogłoszeń mieszkań z podziałem na dzielnice.
#  1. Napisz funkcje ``mean_price``, która zwróci średnią cenę mieszkania ``room_numer``-pokojowego.
#  1. Uzupełnij funkcje ``find_13``, która zwróci listę dzielnic, które zawierają ofertę mieszkanie na 13 piętrze.
#  1. Napisz funkcje ``find_best_flats``, która zwróci wszystkie ogłoszenia mieszkań, które znajdują się na Winogradach, mają 3 pokoje i są położone na 1 piętrze.
#  1. *(dodatkowe)*: Korzystając z pakietu *sklearn* zbuduj model regresji liniowej, która będzie wyznaczać cenę mieszkania na podstawie wielkości mieszkania i liczby pokoi.

import pandas as pd
import re
from sklearn import *
import numpy as np


def wczytaj_dane():
    flats_data = pd.read_csv('mieszkania.csv', encoding='utf-8', sep=',', index_col='Id')
    flats_as_frame = pd.DataFrame(flats_data)
    return flats_as_frame


def most_common_room_number(dane):
    rooms = dane['Rooms']
    rooms_counter = rooms.value_counts()
    rooms_counter_dict = rooms_counter.to_dict()
    max_room = max(rooms_counter_dict, key=rooms_counter_dict.get)
    return max_room


def cheapest_flats(dane, n):
    sorted_flats_data = dane.sort_values(by=['Expected'])
    first_n_cheapest_flats = sorted_flats_data[:n]
    return first_n_cheapest_flats


def find_borough(desc):
    dzielnice = ['Stare Miasto',
                 'Wilda',
                 'Jeżyce',
                 'Rataje',
                 'Piątkowo',
                 'Winogrady',
                 'Miłostowo',
                 'Dębiec']

    # using regular expression to get rid of all special characters with the exception of accents
    final_desc_wo_spaces = re.sub(u'[^a-zA-Z0-9áąéęćíóúÁÉÍÓÚâêîôÂÊÎÔńãõÃÕçÇżź:]', ' ', desc)
    final_desc_wo_spaces = final_desc_wo_spaces.split()
    for n in final_desc_wo_spaces:
        if n in dzielnice:
            return n
        # horrible hack to match 'Stare' with 'Miasto'
        elif n == 'Stare':
            return 'Stare Miasto'
    return "Inne"


def add_borough(dane):
    dane['Borough'] = dane['Location'].apply(find_borough)
    return dane


def write_plot(dane, filename):
    bar_plot_data = dane['Borough']
    counter = bar_plot_data.value_counts()
    my_plot = counter.plot(kind='bar', title='Liczba mieszkań w Poznaniu według dzielnicy', figsize=(12, 12))
    my_plot.set_xlabel('Dzielnica')
    my_plot.set_ylabel('Liczebność')
    fig = my_plot.get_figure()
    fig.savefig(filename + '.png')


def mean_price(dane, room_number):
    filtered_data_mean = dane[dane['Rooms'] == room_number]['Expected'].mean()
    return filtered_data_mean


def find_13(dane):
    filtered_data_floor_13 = dane[dane['Floor'] == 13]['Borough'].values
    return filtered_data_floor_13


def find_best_flats(dane):
    filtered_data = dane.loc[(dane['Borough'] == 'Winogrady') & dane['Rooms'].isin([3]) & dane['Floor'].isin([1])]
    return filtered_data['Description']


def percentile_based_outlier(dane, confidence=95):
    """
    Filters data set by given confidence criterion
    :param dane: 
    :param confidence: 
    :return: 
    """
    diff = (100 - confidence) / 2.0
    minval, maxval = np.percentile(dane['Expected'], [diff, 100 - diff])
    return dane[(dane['Expected'] > minval) & (dane['Expected'] < maxval)]


def linear_regression(dane, powierzchnia, liczba_pokoi):
    # remove outliers and define the data/predictors as the pre-set feature name
    dane_filtered = percentile_based_outlier(dane)
    features = dane_filtered[['SqrMeters', 'Rooms']]
    target = dane_filtered['Expected']
    # print(min(target), max(target))

    x = features
    y = target

    lm = linear_model.LinearRegression()
    lm.fit(x, y)
    model_score = lm.score(x, y)

    # calculate mean squared error
    mse = np.mean((dane_filtered['Expected'] - lm.predict(x)) ** 2)
    price = lm.intercept_ + powierzchnia * lm.coef_[0] + liczba_pokoi * lm.coef_[1]

    co = list(zip(x.columns, lm.coef_))
    coef = pd.DataFrame(co, columns=['feature', 'coefficient'])

    print('Features and coefficients \n {}'.
          format(coef))
    print('Estimated intercept coefficient: {}'.
          format(lm.intercept_))
    print('Number of coefficients {}'.
          format(lm.coef_))  # list of coefficients
    print('R^2 of the prediction: {}'.
          format(model_score))
    print('Mean squared error {}'.
          format(mse))
    print('{} squared meter flat, which has {} rooms with should cost {} PLN'.
          format(powierzchnia, liczba_pokoi, round(price, 4)))


def main():
    dane = wczytaj_dane()
    print(dane[:5])

    print("Najpopularniejsza liczba pokoi w mieszkaniu to: {}"
          .format(most_common_room_number(dane)))

    print("{} to najłądniejsza dzielnica w Poznaniu."
          .format(find_borough("Grunwald i Jeżyce")))

    print("Średnia cena mieszkania 3-pokojowego, to: {}"
          .format(mean_price(dane, 3)))

    linear_regression(dane, 100, 4)


if __name__ == "__main__":
    main()