package pt.utl.ist.scripts.runOnce.contacts;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import net.sourceforge.fenixedu.domain.Person;
import net.sourceforge.fenixedu.domain.contacts.EmailAddress;
import net.sourceforge.fenixedu.domain.contacts.PartyContactType;

import org.apache.commons.lang.StringUtils;

import pt.utl.ist.fenix.tools.spreadsheet.CsvReader;
import pt.utl.ist.fenix.tools.spreadsheet.SheetData;
import pt.utl.ist.fenix.tools.spreadsheet.SpreadsheetBuilder;
import pt.utl.ist.fenix.tools.spreadsheet.WorkbookExportFormat;
import pt.utl.ist.scripts.commons.AtomicScript;

public class UpdateInstitutionalAddress extends AtomicScript {

    private File FILE;
    private static final String FILE_PATH = "/home/sfbs/Documents/emails/";

    private final HashSet<EmailInfo> emailInfoSet = new HashSet<EmailInfo>();

    private static enum ImportResult {
        NOT_PROCESSED, NOT_PROCESSED_PERSON_DOESNT_EXIST, IMPORTED, NOT_IMPORTED_ALREADY_HAS_EMAIL,
        NOT_IMPORTED_NO_EMAIL_CONTACTS_DELETED, NOT_IMPORTED_PERSON_DOESNT_EXIST;
    }

    public class EmailInfo {
        String istID;
        String email;
        String prevEmail;
        List<String> deletedEmails;
        ImportResult imported;

        public EmailInfo(String istID, String email) {
            super();
            this.istID = istID;
            this.email = email;
            this.imported = ImportResult.NOT_PROCESSED;
        }

        public void setDeletedEmails(List<String> emails) {
            deletedEmails = emails;
        }
    }

    @Override
    protected void run() throws Exception {
        emailInfoSet.clear();
        System.out.println("load CSV");
        loadCSV();
        System.out.println("update emails");
        updateEmails();
        System.out.println("export result");
        exportResult();
    }

    private void exportResult() {
        SheetData<EmailInfo> sheet = new SheetData<EmailInfo>(emailInfoSet) {

            @Override
            protected void makeLine(EmailInfo item) {
                addCell("ISTID", item.istID);
                addCell("email", item.email);
                addCell("prevEmail", item.prevEmail);
                addCell("result", item.imported);
                addCell("obs", StringUtils.join(item.deletedEmails, ","));
            }

        };

        SpreadsheetBuilder builder = new SpreadsheetBuilder();
        try {
            System.out.println("start export");
            builder.addSheet("institutional-emails", sheet).build(WorkbookExportFormat.EXCEL,
                    FILE_PATH + "institutionalEmailsResult.csv");
            System.out.println("exit.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void updateEmails() {
        int i = 0;
        for (EmailInfo info : emailInfoSet) {
            final Person person = Person.readPersonByIstUsername(info.istID);
            if (person != null) {
                info.prevEmail = person.getInstitutionalEmailAddressValue();
                if (!StringUtils.isEmpty(info.email)) {
                    setEmailAddress(person, info);
                } else {
                    List partyContacts = person.getPartyContacts(EmailAddress.class, PartyContactType.INSTITUTIONAL);
                    List<String> emails = new ArrayList<String>();
                    for (Object contact : partyContacts) {
                        final EmailAddress address = (EmailAddress) contact;
                        emails.add(address.getValue());
                        address.deleteWithoutCheckRules();
                    }
                    info.imported = ImportResult.NOT_IMPORTED_NO_EMAIL_CONTACTS_DELETED;
                    info.setDeletedEmails(emails);
                }
            } else {
                info.imported = ImportResult.NOT_IMPORTED_PERSON_DOESNT_EXIST;
            }

            if (i++ % 100 == 0) {
                System.out.printf("processing %d of %d\n", i, emailInfoSet.size());
            }
        }
    }

    private void setEmailAddress(Person person, EmailInfo info) {
        List<String> removedEmails = new ArrayList<String>();
        final List partyContacts = person.getPartyContacts(EmailAddress.class);
        final String email = info.email;

        if (info.email.equalsIgnoreCase(info.prevEmail)) {
            info.imported = ImportResult.NOT_IMPORTED_ALREADY_HAS_EMAIL;
        } else {
            for (Object partyContact : partyContacts) {
                final EmailAddress emailAddress = (EmailAddress) partyContact;
                String currentValue = emailAddress.getValue();
                if (email.equalsIgnoreCase(currentValue) && !emailAddress.getType().equals(PartyContactType.INSTITUTIONAL)) {
                    emailAddress.deleteWithoutCheckRules();
                    removedEmails.add(String.format("{%s: %s}", emailAddress.getType(), currentValue));
                }
            }
            person.setInstitutionalEmailAddressValue(info.email);
            info.imported = ImportResult.IMPORTED;
            info.setDeletedEmails(removedEmails);
        }
    }

    private void loadCSV() throws IOException {
        FILE = new File(FILE_PATH + "institutionalEmails.csv");
        final List<Map<String, String>> readCsvFile = CsvReader.readCsvFile(FILE, ",", "UTF-8");
        for (Map<String, String> line : readCsvFile) {
            final String istid = line.get("istid");
            final String email = line.get("email");
            emailInfoSet.add(new EmailInfo(istid, email));
        }
    }

    public static void main(String... args) {
        processWriteTransaction(new UpdateInstitutionalAddress());
    }

}