/*
  This file is part of datajams-evictions.

  datajams-evictions is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  datajams-evictions is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License
  along with datajams-evictions.  If not, see <https://www.gnu.org/licenses/>.

  Copyright 2020 Luigi Bai
*/
const DAO = require("./lib/sqlDAO");
const Court = require("./lib/Court.class");
const OI = require("./lib/OdysseyInfo.class");

let today = new Date();
let future = (new Date(today.valueOf()));
future.setDate(today.getDate() + 6);

// Emit the CSV headers; we get a line for each case, below:
console.log(
    '"Case Number",',
    '"Precinct",',
    '"Place",',
    '"Date",',
    '"Time",',
    '"DateTime",',
    '"Claim",',
    '"Plaintiff",',
    '"Defendant 1",',
    '"Defendant 2",',
    '"Defendant 3",',
    '"Case URL",',
    '"Docket URL"'
);

let opts = require("./creds")["SQLITE3"];

opts.connectCallback = (database) => {
    let casePromises = [];
    let oiPromises = [];
    // Prep the databse to update each case as we get its updated info:
    let pDao = new DAO.PartyCtlr(database);
    pDao.stmts.update = pDao.prepare(
	database,
	"UPDATE party SET party_address = $pa WHERE casenumber = $cnum AND party_role = $pr AND party_name = $pn"
    );
    pDao.ignoreInsertErrors = true;

    let cDao = new DAO.CaseCtlr(database);
    cDao.stmts.update = cDao.prepare(
	database,
	"UPDATE cases SET odyssey_ID = $oid WHERE casenumber = $cnum"
    );	    

    // Loop over all 8 precincts, two places per precinct:
    for (let pct = 1; pct <= 8; pct ++) {
	for (let plc = 1; plc <= 2; plc ++) {
	    // param is pct * 10 + plc:
	    let court = new Court({
		precinct: pct,
		place: plc
	    });

	    casePromises.push(court.getDockets({
		startDate: today,
		endDate: future,
		docketType: "Eviction Docket",
		caseCallback: (caseObj) => {
		    // First, store the case into the database:
		    caseObj.storeSQL(database);

		    if (!caseObj.caseNumber) {
			console.error("Can't find casenumber to load OI on case", caseObj);
		    } else {
			// Does it already have an OdysseyID?
			database.get(
			    "SELECT * FROM cases WHERE casenumber = $cn AND odyssey_ID IS NULL",
			    { $cn: caseObj.caseNumber },
			    (err, row) => {
				if (err) {
				    console.error("Error finding OI for case", caseObj, err);
				} else if (row) {
				    // Then, try to load the OI:
				    oiPromises.push(
					new OI(row.casenumber)
					    .findCasePromise()
					    .then(oi => {
						// Store the OdysseyID into Cases
						cDao.update({
						    $cnum: oi.caseNumber,
						    $oid: oi.caseID
						});
						// Store the party addresses
						oi.parties.forEach(party => {
						    if (party.address) {
							// If this has been a bulk extract,
							// probably should insert first, given
							// the bulk extracts only have 2 parties
							// per case.
							pDao.insert({
							    $addr: party.address.join(" "),
							    $cnum: oi.caseNumber,
							    $role: party.role,
							    $name: party.name
							});
							pDao.update({
							    $pa: party.address.join(" "),
							    $cnum: oi.caseNumber,
							    $pr: party.role,
							    $pn: party.name
							});
						    }
						});
						return {
						    msg: "OI stored",
						    case: row.casenumber
						};
					    })
					    .catch(err => {
						return {
						    msg: "Error retrieving OI",
						    case: row.casenumber,
						    err: err
						};
					    })			
				    );		    
				}
			    }
			);
		    }


		    // These functions allow the "pivot" below on each case:
		    let plaintiffs = caseObj.parties.filter((party) => {
			return ("Plaintiff" === party.role);
		    });
		    let defendants = caseObj.parties.filter((party) => {
			return ("Defendant" === party.role);
		    });

		    // See the CSV header above? Emit each case to that format:
		    console.log(
			caseObj.caseNumber + ",",
			caseObj.docket.court.precinct + ",",
			caseObj.docket.court.place + ",",
			caseObj.docket.date + ",",
			caseObj.docket.time + ",",
			'"' +
			    caseObj.docket.date.substr(6)+"-"+
			    caseObj.docket.date.substr(0, 2)+"-"+
			    caseObj.docket.date.substr(3, 2)+" "+
			    caseObj.docket.time
			    + '",',
			'"' + caseObj.claimAmount + '",',
			(plaintiffs.length > 0) ? '"' + plaintiffs[0].name + '",' : '"",',
			(defendants.length > 0) ? '"' + defendants[0].name + '",' : '"",',
			(defendants.length > 1) ? '"' + defendants[1].name + '",' : '"",',
			(defendants.length > 2) ? '"' + defendants[2].name + '",' : '"",',
			'"' + caseObj.URL + '",',
			'"' + caseObj.docket.URL.href +'"'
		    );
		}
	    }));
	}
    }

    // Wait for all the dockets to load, then emit their info:
    Promise.all(casePromises)
	.then(val => {
	    console.error("Finished loading all dockets from all courts.");
	    // Wait for the OIs to finish:
	    Promise.all(oiPromises)
		.then(val => { console.error("Finished loading OIs."); })
		.catch(err => { console.error("Error loading OIs", err); })
		.finally(() => {
		    (require("./lib/httpOptions").getGlobalAgent().destroy());
		    pDao.finalize();
		    cDao.finalize();
		    DAO.disconnect(database);
		});
	    ;
	})
	.catch(err => { console.error("Error loading dockets", err); })
    ;
};

DAO.connect(opts);