/* model_process_event is the main point where events are post-processed from
 * a relay. Additionally other side effects happen such as notification checks
 * and fetching of unknown pubkey profiles.
 */
function model_process_event(model, ev) {
	if (model.all_events[ev.id]) {
		return;
	}

	model.all_events[ev.id] = ev;
	ev.refs = event_get_tag_refs(ev.tags);
	ev.pow = event_calculate_pow(ev);

	// Process specific event needs based on it's kind. Not using a map because
	// integers can't be used.
	let fn;
	switch(ev.kind) {
		case KIND_METADATA:
			fn = model_process_event_profile;
			break;
		case KIND_CONTACT:
			fn = model_process_event_contact;
			break;
		case KIND_DELETE:
			fn = model_process_event_deletion;
			break;
		case KIND_REACTION:
			fn = model_process_event_reaction;
			break;
	}
	if (fn)
		fn(model, ev);

	// check if the event that just came in should notify the user and is newer
	// than the last recorded notification event, if it is notify
	const notify_user = event_refs_pubkey(ev, model.pubkey)
	const last_notified = get_local_state('last_notified_date')
	ev.notified = notify_user;
	if (notify_user && (last_notified == null || ((ev.created_at*1000) > last_notified))) {
		set_local_state('last_notified_date', new Date().getTime());
		model.notifications++;
		update_title(model);
	}

	// If we find some unknown ids lets schedule their subscription for info
	if (model_event_has_unknown_ids(model, ev))
		schedule_unknown_refetch(model);

	// Queue event for rendering  
	model.invalidated.push(ev.id);
}

/* model_process_event_profile updates the matching profile with the contents found 
 * in the event.
 */
function model_process_event_profile(model, ev) {
	const prev_ev = model.all_events[model.profile_events[ev.pubkey]]
	if (prev_ev && prev_ev.created_at > ev.created_at)
		return
	model.profile_events[ev.pubkey] = ev.id
	model.profiles[ev.pubkey] = safe_parse_json(ev.content, "profile contents")
	view_timeline_update_profiles(model, ev);
}

function model_process_event_contact(model, ev) {
	contacts_process_event(model.contacts, model.pubkey, ev)
	load_our_relays(model.pubkey, model.pool, ev)
}

/* model_process_event_reaction updates the reactions dictionary
 */
function model_process_event_reaction(model, ev) {
	let reaction = event_parse_reaction(ev);
	if (!reaction) {
		return;
	}
	if (!model.reactions_to[reaction.e])
		model.reactions_to[reaction.e] = new Set();
	model.reactions_to[reaction.e].add(ev.id);	
	view_timeline_update_reaction(model, ev);
}

/* event_process_deletion updates the list of deleted events. Additionally
 * pushes event ids onto the invalidated stack for any found.
 */
function model_process_event_deletion(model, ev) {
	for (const tag of ev.tags) {
		if (tag.length >= 2 && tag[0] === "e" && tag[1]) {
			let evid = tag[1];
			model.invalidated.push(evid);
			model_remove_reaction(model, evid);
			if (model.deleted[evid])
				continue;
			let ds = model.deletions[evid] =
				(model.deletions[evid] || new Set());
			ds.add(ev.id);
		}
	}
}

function model_remove_reaction(model, evid) {
	// deleted_ev -> target_ev -> original_ev
	// Here we want to find the original react event to and remove it from our
	// reactions map, then we want to update the element on the page. If the 
	// server does not clean up events correctly the increment/decrement method
	// should work fine in theory.
	const target_ev = model.all_events[evid];
	if (!target_ev)
		return;
	const reaction = event_parse_reaction(target_ev);
	if (!reaction)
		return;
	if (model.reactions_to[reaction.e])
		model.reactions_to[reaction.e].delete(target_ev.id);
	view_timeline_update_reaction(model, target_ev);
}

/* model_event_has_unknown_ids checks the event if there are any referenced keys with
 * unknown user profiles in the provided scope.
 */
function model_event_has_unknown_ids(damus, ev) {
	// make sure this event itself is removed from unknowns
	if (ev.kind === 0)
		delete damus.unknown_pks[ev.pubkey]
	delete damus.unknown_ids[ev.id]
	let got_some = false
	for (const tag of ev.tags) {
		if (tag.length >= 2) {
			if (tag[0] === "p") {
				const pk = tag[1]
				if (!model_has_profile(damus, pk) && is_valid_id(pk)) {
					got_some = true
					damus.unknown_pks[pk] = make_unk(tag[2], ev)
				}
			} else if (tag[0] === "e") {
				const evid = tag[1]
				if (!model_has_event(damus, evid) && is_valid_id(evid)) {
					got_some = true
					damus.unknown_ids[evid] = make_unk(tag[2], ev)
				}
			}
		}
	}
	return got_some
}

function model_is_event_deleted(model, evid) {
	// we've already know it's deleted
	if (model.deleted[evid])
		return model.deleted[evid]

	const ev = model.all_events[evid]
	if (!ev)
		return false

	// all deletion events
	const ds = model.deletions[ev.id]
	if (!ds)
		return false

	// find valid deletion events
	for (const id of ds.keys()) {
		const d_ev = model.all_events[id]
		if (!d_ev)
			continue
		
		// only allow deletes from the user who created it
		if (d_ev.pubkey === ev.pubkey) {
			model.deleted[ev.id] = d_ev
			delete model.deletions[ev.id]
			return true
		}
	}
	return false
}

function model_has_profile(model, pk) {
	return pk in model.profiles
}

function model_has_event(model, evid) {
	return evid in model.all_events
}

/* model_relay_update_lok returns a map of kinds found in all events based on 
 * the last seen event of each kind. It also updates the model's cached value.
 * If the cached value is found it returns that instead
 */
function model_relay_update_lok(model, relay) {
	let last_of_kind = model.last_event_of_kind[relay];
	if (!last_of_kind) {
		last_of_kind = model.last_event_of_kind[relay] 
			= calculate_last_of_kind(model.all_events);
	}
	return last_of_kind;
}

function model_subscribe_defaults(model, relay) {
	const lok = model_relay_update_lok(model, relay);
	const filters = filters_new_default_since(model, lok);
	filters_subscribe(filters, model.pool, [relay]);
}

function model_events_arr(model) {
	const events = model.all_events;
	let arr = [];
	for (const evid in events) {
		const ev = events[evid];
		const i = arr_bsearch_insert(arr, ev, event_cmp_created); 
		arr.splice(i, 0, ev);
	}
	return arr;
}

function test_model_events_arr() {
	const arr = model_events_arr({all_events: {
		"c": {name: "c", created_at: 2},
		"a": {name: "a", created_at: 0},
		"b": {name: "b", created_at: 1},
		"e": {name: "e", created_at: 4},
		"d": {name: "d", created_at: 3},
	}});
	let last;	
	while(arr.length > 0) {
		let ev = arr.pop();
		log_debug("test:", ev.name, ev.created_at);
		if (!last) {
			last = ev;
			continue;
		}
		if (ev.created_at > last.created_at) {
			log_error(`ev ${ev.name} should be before ${last.name}`);
		}
		last = ev;
	}
}

async function model_save_events(model) {
	function _events_save(ev, resolve, reject) {
		const db = ev.target.result;
		let tx = db.transaction("events", "readwrite");
		let store = tx.objectStore("events");
		for (const evid in model.all_events) {
			store.put(model.all_events[evid]);
		}
		tx.oncomplete = (ev) => {
			db.close();
			resolve();
			log_debug("saved events!");
		};
		tx.onerror = (ev) => {
			db.close();
			log_error("failed to save events");
			reject(ev);
		};
	}
	return dbcall(_events_save);
}

async function model_load_events(model, fn) {
	function _events_load(ev, resolve, reject) {
		const db = ev.target.result;
		const tx = db.transaction("events", "readonly");
		const store = tx.objectStore("events");
		const cursor = store.openCursor();
		cursor.onsuccess = (ev) => {
			var cursor = ev.target.result;
			if (cursor) {
				fn(cursor.value);
				cursor.continue();
			} else {
				db.close();
				resolve();
				log_debug("Successfully loaded events");
			}
		}
		cursor.onerror = (ev) => {
			db.close();
			reject(ev);
			log_error("Could not load events.");
		};
	}
	return dbcall(_events_load);
}

function new_model() {
	return {
		all_events: {}, // our master list of all events
		done_init: {},
		notifications: 0,
		max_depth: 2,
		reactions_to: {},
		chatrooms: {},
		
		unknown_ids: {},
		unknown_pks: {},
		but_wait_theres_more: 0,
		
		deletions: {},
		deleted: {},
		last_event_of_kind: {},
		pow: 0, // pow difficulty target
		profiles: {}, // pubkey => profile data
		profile_events: {}, // pubkey => event id - use with all_events
		contacts: {
			event: null,
			friends: new Set(),
			friend_of_friends: new Set(),
		},
		invalidated: [], // event ids which should be added/removed
		elements: {}, // map of evid > rendered element
		requested_profiles: [], // an array of {relay_id, pubkey} to fetching

		ids: {
			comments:      "comments",
			explore:       "explore",
			refevents:     "refevents",
			account:       "account",
			home:          "home",
			contacts:      "contacts",
			notifications: "notifications",
			unknowns:      "unknowns",
			dms:           "dms",
		},
	};
}