import {Injectable} from '@angular/core';
import {PollConfig} from '../config/PollConfig';
import {HttpClient} from "@angular/common/http";
import {environment} from "../../environments/environment";
import {ConfirmationService, MessageService} from 'primeng/api';
import {Router} from "@angular/router";
import {mockMyPolls} from "../config/mocks/mockmypolls";
import {mockPoll3} from "../config/mocks/mock-poll3";
import {mockSuccessVote} from "../config/mocks/mock-success-vote";
import {PollUtilities} from "../config/PollUtilities";

/**
 * le service transverse à chaque page qui permet de syncroniser la configuration de sondage souhaitée
 */
@Injectable({
    providedIn: 'root'
})
export class ConfigService extends PollConfig {

    loading: boolean = false;
    baseHref: any = environment.baseApiHref;


    constructor(private http: HttpClient,
                private messageService: MessageService,
                private router: Router,
                private utils: PollUtilities,
                private confirmationService: ConfirmationService,
    ) {
        super();
        this.fillValuesOnDevEnv();
    }

    set(key, val) {
        this[key] = val;
    }

    // fill in mock values if we are not in production environment
    fillValuesOnDevEnv() {

        if (!environment.production) {
            console.info(' ######### framadate ######### we are not in production env, filling with mock values');
            this.currentPoll = mockPoll3;
            this.myPolls = mockMyPolls;
        }
    }

    /**
     * add some days to a date, to compute intervals
     * @param days
     * @param date
     */
    addDaysToDate(days: number, date: Date) {
        date = new Date(date.valueOf());
        date.setDate(date.getDate() + days);
        return date;
    };

    /** ==================================
     *
     *  poll public calls to get non authenticated info
     *
     *  ==================================/
     /**
     * convert current poll config to a payload to send to the backend API
     */
    getPollConfig() {
        const jsonConfig = {
            owner: {
                email: this.myEmail,
                pseudo: this.myName,
            },
            title: this.title,
            description: this.description,
            pollType: this.pollType,
            visibility: this.visibility,
            voteChoices: this.voteChoices,
            allowSeveralHours: this.allowSeveralHours,
            expirationDate: this.expirationDate,
            passwordAccess: this.passwordAccess,
            password: this.password,
            customUrl: this.customUrl,
            canModifyAnswers: this.canModifyAnswers,
            whoModifiesAnswers: this.whoModifiesAnswers,
            dateList: this.dateList,
            timeList: this.timeList,
            answers: this.answers,
            expiracyDateDefaultInDays: this.expiracyDateDefaultInDays,
            deletionDateAfterLastModification: this.deletionDateAfterLastModification,
        };
        return jsonConfig
    }


    checkIfSlugIsUniqueInDatabase(slug: string = '') {
        this.customUrlIsUnique = null;
        if (!slug) {
            slug = this.utils.makeSlug(this);
        }

        this.loading = true;
        // TODO
        this.todo('check slug is unique');
        this.http.get(`${this.baseHref}/check-slug-is-uniq/${slug}`,
            this.utils.makeHeaders({slug: this.customUrl}),
        )
            .subscribe((res: any) => {

                    this.customUrlIsUnique = res.poll.isUnique;
                    this.loading = false;
                },
                (e) => this.handleError(e))
        ;
    }

    /**
     * search in localstorage, fallback asking the backend to send an email to the owner if it exists
     * @param email
     */
    findPollsByEmail(email: string) {

        this.findLocalStorageData();
        // If no key is found in the localstorage, ask the backend to send an email to the user

        this.myEmail = email;


        this.todo('send email for real : TODO');
        this.loading = true;
        this.http.get(`${this.baseHref}/send-polls-to-user/${this.myEmail}`,
            this.utils.makeHeaders(),
        )
            .subscribe(res => {
                    //     message: 'Trouvé! Allez voir votre boite email',
                    this.myPolls = res;
                    this.loading = false;
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Succès',
                        detail: `Vos infos de sondages vous ont été transmises. Allez voir votre boite email ${this.myEmail}`
                    });
                }, (e) => {
                    this.handleError(e)
                }
            )
    }


    /**
     * display error message depending on the response of the backend
     * @param err
     */
    handleError(err: any) {
        console.error('err', err);
        this.loading = false;
        this.messageService.add({severity: 'warning', summary: "Erreur lors de l'appel ", detail: err.message});
    }


    findLocalStorageData() {
        // TODO check if the person has a key to retrieve her polls
        console.log('localStorage', localStorage);
        if (localStorage) {
            console.log('localStorage', localStorage)
        }
    }


    /**
     * get one poll by its slug name
     * @param url
     */
    getPollByURL(url: string) {

        this.todo();
        return this.http.get(`${this.baseHref}/poll/slug/${url}`, this.utils.makeHeaders())
    }

    /**
     * GET
     * api/v1/poll/{id}
     * @param id
     */
    getPollById(id: string, password?: string) {

        return this.http
            .get(`${this.baseHref}/poll/${id}`,
                this.utils.makeHeaders({body: password}))
    }

    fetchPollFromRoute(event) {
        console.log('time to fetch poll', event)
    }

    /**
     * GET
     * api/v1/my-polls
     * @param ownerEmail
     */
    getMyPolls(ownerEmail: string) {
        this.http
            .get(`${this.baseHref}/my-polls`,
                this.utils.makeHeaders({ownerEmail: ownerEmail})
            )
            .subscribe(
                (res: any) => {
                    // this.myPolls = res.poll;
                }, (e) => {
                    this.handleError(e)
                }
            );
    }


    /**
     * launch creation call to the api
     */
    createPoll() {
        this.loading = true;
        this.createPollFromConfig(this.getPollConfig())
    }

    updateCurrentPollFromResponse(res: any) {
        console.log('update res', res);
        this.currentPoll = res;
        this.pollId = res.poll.id;
        this.owner_modifier_token = res.owner_modifier_token;
        this.urlPublic = this.baseHref + '#/vote/poll/id/' + res.poll.id;
        this.urlSlugPublic = this.baseHref + '#/vote/poll/slug/' + res.poll.id;
        if (res.poll.customUrl) {
            this.urlSlugPublic = this.baseHref + '#/vote/poll/id/' + res.poll.customUrl;
        }
        if (res.voteStack) {
            this.loadVoteStack(res.voteStack);
        }
        this.adminKey = res.admin_key;
        this.urlAdmin = this.baseHref + '#/admin/' + res.admin_key;
    }

    resetCurrentChoicesAnswers() {
        this.currentPoll.choices.map(choice => {
            choice.answer = null;
        })
    }

    /**
     * update current answers with a previous vote
     * @param voteStack
     */
    loadVoteStack(voteStack: any) {

        // load the pseudo and email
        this.myName = voteStack.pseudo;
        this.myEmail = voteStack.email;
        this.voteStackId = voteStack.id;
        this.myVoteStack = voteStack;
        let keys = Object.keys(voteStack.votes);
        console.log('voteStack', voteStack);
        this.resetCurrentChoicesAnswers();
        keys.forEach((id: any) => {
            let voteItem = voteStack.votes[id];

            /**
             * the display of the poll uses the choices data, so we update the choices answers of the current poll to reflect the vote stack we have taken
             */
            if (voteItem.choice_id && voteItem.value) {
                let foundChoiceToModify = this.currentPoll.choices.find(choicesItem => {
                    return voteItem.choice_id == choicesItem.id
                });
                console.log('foundChoiceToModify', foundChoiceToModify);
                if (foundChoiceToModify) {
                    foundChoiceToModify.answer = voteItem.value;
                }
            }
        })
    }

    /**
     * POST
     * /api/v1/poll/{id}/poll
     * @param config
     */
    createPollFromConfig(config: any) {
        this.loading = true;
        console.log('config', config);
        return this.http.post(`${this.baseHref}/poll`,
            config,
            this.utils.makeHeaders())
            .subscribe((res: any) => {
                    // redirect to the page to administrate the new poll
                    this.messageService.add({severity: 'success', summary: 'Sondage Créé',});

                    this.updateCurrentPollFromResponse(res);

                    this.loading = false;
                    if (!this.myPolls) {
                        this.myPolls = [];
                    }
                    this.myPolls.push(res);
                    this.router.navigate(['step/end']);
                    // TODO save new poll to localstorage
                    // reset all fields in current config
                    this.resetConfig();
                }, (e) => {
                    this.handleError(e)
                }
            );
    }

    /**
     * conversion to send to back
     * @param choiceList
     */
    convertChoicesAnsweredToSend(choiceList) {
        choiceList = choiceList.filter(c => c.answer ? c : null); // remove choices where we did not answer
        const converted = choiceList.map(elem => {
            if (elem.answer) {
                return {
                    choice_id: elem.id,
                    value: elem.answer
                }
            }
        });
        console.log('converted', converted);
        return converted;
    }

    /**
     * POST
     * /api/v1/poll/{id}/vote
     * @param voteStack
     */
    addVote(voteStack?: any) {
        if (!voteStack) {
            voteStack = {
                pseudo: this.myName,
                email: this.myEmail,
                votes: this.convertChoicesAnsweredToSend(this.currentPoll.choices),
            }
        }
        this.myVoteStack = voteStack;

        if (!environment.production) {
            this.handleVoteAdded(mockSuccessVote);
            return;
        }
        this.http.post(
            `${this.baseHref}/poll/${this.pollId}/vote`,
            voteStack,
            this.utils.makeHeaders())
            .subscribe((res: any) => {

                    this.handleVoteAdded(res);
                }, (e) => {
                    this.handleError(e)
                }
            );
    }

    handleVoteAdded(res) {
        this.messageService.add({severity: 'success', summary: 'Vote ajouté'});
        // save modifier token
        this.myVoteStack['modifier_token'] = res.modifier_token;
        this.myVoteStack['id'] = res.vote_stack.id;
        this.updateCurrentPollFromResponse(res);
    }

    /**
     * UPDATE
     * /api/v1/poll/{id}/vote
     * @param voteStack
     */
    updateVote(voteStack?: any) {
        if (!this.myVoteStack) {
            return;

        } else {
            voteStack = this.myVoteStack;
        }
        this.http.patch(
            `${this.baseHref}/vote-stack/${voteStack.id}/token/${this.owner_modifier_token}`,
            voteStack,
            this.utils.makeHeaders())
            .subscribe((res: any) => {
                    this.messageService.add({severity: 'success', summary: 'Vote mis à jour'});
                    this.updateCurrentPollFromResponse(res);
                }, (e) => {
                    this.handleError(e)
                }
            );
    }

    /**
     * POST
     * /api/v1/poll/{id}/comment
     * @param comment
     */
    addComment(comment?: any) {
        if (!comment && this.myComment) {
            comment = {
                name: this.myName,
                pseudo: this.myName,
                email: this.myEmail,
                date: new Date(),
                text: this.myComment,
            }
        }
        console.log('comment', comment);
        this.http.post(
            `${this.baseHref}/poll/${this.pollId}/comment`,
            comment,
            this.utils.makeHeaders())
            .subscribe((res: any) => {
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Commentaire Créé',
                        detail: comment.text
                    });
                    // empty comment after success
                    this.myComment = '';
                    comment.date = {
                        date: comment.date
                    };
                    this.currentPoll.comments.push(comment);
                }, (e) => {
                    this.handleError(e);
                }
            );
    }


    /**
     * administrator calls
     */

    deleteComments() {
        // prompt for confirmation
        this.confirmationService.confirm({
            message: 'Are you sure that you want to completely delete the comments of this poll (' + this.title + ') permanentely?',
            accept: () => {
                this.http.delete(
                    `${this.baseHref}/poll/${this.pollId}/comments`,
                    this.utils.makeHeaders())
                    .subscribe((res: any) => {
                            this.messageService.add({
                                severity: 'success',
                                summary: 'Commentaires bien supprimés',
                                detail: 'Commentaires du sondage "' + this.title + '" supprimé'
                            });

                        }, (e) => {
                            this.handleError(e)
                        }
                    );
            }
        });
    }

    deleteVotes() {
        // prompt for confirmation
        this.confirmationService.confirm({
            message: 'Are you sure that you want to completely delete the votes of this poll (' + this.title + ') permanentely?',
            accept: () => {
                this.http.delete(
                    `${this.baseHref}/poll/${this.pollId}/votes`,
                    this.utils.makeHeaders())
                    .subscribe((res: any) => {
                            this.messageService.add({
                                severity: 'success',
                                summary: 'Votes bien supprimés',
                                detail: 'Votes du sondage "' + this.title + '" supprimé'
                            });

                        }, (e) => {
                            this.handleError(e)
                        }
                    );
            }
        });
    }

    deletePoll() {
        if (!this.pollId) {
            this.messageService.add({
                summary: 'this poll is not administrable, it has no ID',
                severity: 'warning'
            });
            return;
        }
        let self = this;
        // prompt for confirmation
        this.confirmationService.confirm({
            message: 'Are you sure that you want to completely delete this poll (' + self.title + ') and all is data permanentely?',
            accept: () => {
                this.http.delete(
                    `${this.baseHref}/poll/${this.pollId}`,
                    this.utils.makeHeaders())
                    .subscribe((res: any) => {
                            this.messageService.add({
                                severity: 'success',
                                summary: 'Sondage bien supprimé',
                                detail: 'sondage "' + this.title + '" supprimé'
                            });

                            this.router.navigate(['home']);
                        }, (e) => {
                            this.handleError(e)
                        }
                    );
            }
        });
    }

    /**
     * UPDATE
     * /api/v1/poll/{id}/vote
     * @param voteStack
     * TODO
     */
    updatePoll(voteStack: any) {
        this.http.put(
            `${this.baseHref}/poll/${this.pollId}`,
            voteStack,
            this.utils.makeHeaders()
        )
            .subscribe((res: any) => {
                    this.messageService.add({
                        severity: 'success',
                        summary: 'Sondage mis à jour',
                    });
                    this.updateCurrentPollFromResponse(res);
                }, (e) => {
                    this.handleError(e)
                }
            );
    }

    /**
     *  TODO
     * export all the poll data available to the public as a CSV single file
     */
    exportCSV() {


        let rows = [];
        let now = new Date();
        const headers = [
            ['export de sondage Framadate ', this.customUrl],
            ['le', now.toISOString()],
            [this.currentPoll.pollId, this.currentPoll.title, this.customUrl, this.creationDate],
            ['pseudo']];


        let listOfChoices = ['choices : '];
        this.currentPoll.choices.map(choice => {
            listOfChoices.push(choice.text)
        });
        listOfChoices.push('pseudo');

        this.currentPoll.stacks.map(voteStack => {
            let voteStackInArray = [voteStack.pseudo];
            let keysVotes = Object.keys(voteStack.votes);

            keysVotes.map(id => {
                voteStackInArray.push(voteStack.votes[id].value ? voteStack.votes[id].value : "")
            });
            rows.push(
                voteStackInArray
            );
        });
        const headersComments = [
            ['comments'],
            ['pseudo', 'text', 'creation_date'],
        ];
        const comments = [];
        this.currentPoll.comments.map(item => {
            comments.push(
                [item.pseudo,
                    item.text,
                    item.date.date,
                    '\n']
            )
        });
        headers.push(listOfChoices);
        rows = [headers, listOfChoices, rows, headersComments, comments];

        let convertedCsv = rows.map(elem => {
            console.log('elem', elem);
            return elem.map(item => {
                console.log('item', item);
                if (typeof item === typeof Array) {
                    return item.join('\n')
                }
                return item;
            }).join('\n')
        }).join('\n');
        console.log('rows', rows);
        console.log('convertedCsv', convertedCsv);

        let csvContent = "data:text/csv;charset=utf-8,"
            + convertedCsv;
        console.log('csvContent', csvContent);
        var encodedUri = encodeURI(csvContent);
        var link = document.createElement("a");
        link.setAttribute("href", encodedUri);
        let exportFileName = (this.urlPublic ? this.urlPublic : this.utils.makeSlug(this)) + "_export_" + new Date() + ".csv";
        link.setAttribute("download", exportFileName);
        document.body.appendChild(link); // Required for FF
        link.click(); // This will download the data file named "my_data.csv".
    }

    print() {
        alert('TODO');
    }

    todo(message = '') {
        this.messageService.add({
            severity: 'info' + message,
            detail: "cette fonctionnalité n'est pas encore disponible. Venez en discuter sur framateam.org / Ux et design libre / Framasoft",
            summary: "Work in progress",
        });
    }
}