import { Injectable } from '@angular/core';
import { Http, Response, RequestOptions } from '@angular/http';
import { Subject } from 'rxjs/Subject';

import 'rxjs/Rx';
import { Observable } from "rxjs";
import 'rxjs/add/operator/map';
import 'google-picker';

@Injectable()
export class EvaluationsService {



    private http: Http;

    private saveEvaluationUrl = '/add-evaluation';
    private saveSubjectsUrl = '/save-subjects';
    private getEvaluationsUrl = '/list-evaluations';
    private deleteEvaluationsUrl = '/delete-evaluation';
    private analyzeUrl = '/analyze-evaluation';
    private updateUrl = '/update-caee';
    private sendEmailUrl = '/send-email';
    private getResultUrl = '/get-subjects';
    private getReportUrl = '/get-report';
    listChanged = new Subject<void>();

    constructor(http: Http) {
        this.http = http;
    }


    saveEvaluation(evaluationData, callback, errHandler) {
        this.http.post(this.saveEvaluationUrl, evaluationData)
        .map( (response : Response) =>{
            return response;
        } )
        .subscribe(
            (data) => {
                callback();
                this.listChanged.next();
            },
            (data) =>{
                errHandler();
            }
        );
    }

    saveSubjects() {
        return this.http.post(this.saveSubjectsUrl,{})
            .map((response: Response) => response.json())
            .catch((error: Response) => Observable.throw(error.json()));
    }

    getEvaluationsList(callback){
        this.http.get(this.getEvaluationsUrl)
        .map( (response : Response) => {
            return response;
        })
        .subscribe(
            (data) =>{
                callback(data.json().obj);
            },
            (data) => {
                window.alert('Nao foi possivel pegar a lista de avaliacoes!');
                return [];
            }
        );
    }

    deleteEvaluation(id, callback){
        this.http.delete(this.deleteEvaluationsUrl, new RequestOptions({
            body: {id: id}
         }))
        .map( (response : Response) => {
            return response;
        })
        .subscribe(
            (data) =>{
                window.alert('Avaliacao deletada com sucesso!');
                this.listChanged.next();
            },
            (data) => {
                window.alert('Nao foi possivel deletar a avaliacao!');
            }
        );
    }

    analyzeEvaluation(data, callback){
        console.log(data);
        this.http.post(this.analyzeUrl, data)
        .map( (response : Response) =>{
            return response;
        } )
        .subscribe(
            (data) => {
                callback();
                this.listChanged.next();
            },
            (data) =>{
                callback();
            }
        );
    }

    sendEmail(data, callback, errHandler){
        console.log(data);
        this.http.post(this.sendEmailUrl, data)
        .map( (response : Response) =>{
            return response;
        } )
        .subscribe(
            (data) => {
                callback();
            },
            (data) =>{
                errHandler();
            }
        );
    }

    updateCAEE(callback){
        this.http.get(this.updateUrl)
        .map( (response : Response) =>{
            return response;
        } )
        .subscribe(
            (data) => {
                callback();
            },
            (data) =>{
                callback();
            }
        );
    }

    getResult(callback){
        this.http.get(this.getResultUrl)
            .map( (response : Response) => {
                return response;
            })
            .subscribe(
                (data) =>{
                    callback(data.json().obj);
                },
                (data) => {
                    window.alert('Nao foi possivel pegar a lista de avaliacoes!');
                    return [];
                }
            );
    }

    getReport(data, callback, errHandler){
        this.http.post(this.getReportUrl, data)
        .map( (response : Response) =>{
            return response;
        } )
        .subscribe(
            (data) => {
                callback();
            },
            (data) =>{
                errHandler();
            }
        );
    }



}