package me.mrletsplay.shareclient;

import java.io.IOException;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IStartup;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;

import me.mrletsplay.shareclient.util.ChecksumUtil;
import me.mrletsplay.shareclient.util.Peer;
import me.mrletsplay.shareclient.util.ProjectAndPath;
import me.mrletsplay.shareclient.util.ProjectRelativePath;
import me.mrletsplay.shareclient.util.ShareSession;
import me.mrletsplay.shareclient.util.SharedProject;
import me.mrletsplay.shareclient.util.SyncState;
import me.mrletsplay.shareclient.util.listeners.ShareClientDocumentListener;
import me.mrletsplay.shareclient.util.listeners.ShareClientPageListener;
import me.mrletsplay.shareclient.util.listeners.ShareClientPartListener;
import me.mrletsplay.shareclient.util.listeners.ShareClientWindowListener;
import me.mrletsplay.shareclient.views.ShareView;
import me.mrletsplay.shareclientcore.connection.ConnectionException;
import me.mrletsplay.shareclientcore.connection.DisconnectListener;
import me.mrletsplay.shareclientcore.connection.MessageListener;
import me.mrletsplay.shareclientcore.connection.RemoteConnection;
import me.mrletsplay.shareclientcore.connection.WebSocketConnection;
import me.mrletsplay.shareclientcore.connection.message.AddressableMessage;
import me.mrletsplay.shareclientcore.connection.message.ChangeMessage;
import me.mrletsplay.shareclientcore.connection.message.ChecksumMessage;
import me.mrletsplay.shareclientcore.connection.message.FullSyncMessage;
import me.mrletsplay.shareclientcore.connection.message.Message;
import me.mrletsplay.shareclientcore.connection.message.PeerJoinMessage;
import me.mrletsplay.shareclientcore.connection.message.PeerLeaveMessage;
import me.mrletsplay.shareclientcore.connection.message.RequestFullSyncMessage;
import me.mrletsplay.shareclientcore.document.Char;
import me.mrletsplay.shareclientcore.document.SharedDocument;

/**
 * The activator class controls the plug-in life cycle
 */
public class ShareClient extends AbstractUIPlugin implements MessageListener, DisconnectListener, IStartup {

	// The plug-in ID
	public static final String PLUGIN_ID = "ShareClient"; //$NON-NLS-1$

	// The shared instance
	private static ShareClient plugin;

	private ShareClientPartListener partListener;

	private ShareView view;
	private ShareSession activeSession;

	public ShareClient() {

	}

	@Override
	public void start(BundleContext context) throws Exception {
		super.start(context);
		plugin = this;
		partListener = new ShareClientPartListener();

		getPreferenceStore().setDefault(ShareClientPreferences.SERVER_URI, "ws://localhost:5473");
		getPreferenceStore().setDefault(ShareClientPreferences.SHOW_CURSORS, true);
//		new ShareWSClient(URI.create("ws://localhost:5473")).connect();

		PlatformUI.getWorkbench().addWindowListener(ShareClientWindowListener.INSTANCE);
		Arrays.stream(PlatformUI.getWorkbench().getWorkbenchWindows()).forEach(w -> {
			w.addPageListener(ShareClientPageListener.INSTANCE);
			Arrays.stream(w.getPages()).forEach(p -> {
				p.addPartListener(partListener);
				Arrays.stream(p.getEditorReferences()).forEach(e -> partListener.addDocumentListener(e));
			});
		});

		ResourcesPlugin.getWorkspace().addResourceChangeListener(event -> Display.getDefault().asyncExec(() -> handleChange(event.getDelta())), IResourceChangeEvent.POST_CHANGE);
		// TODO: handle PRE_CLOSE events?
	}

	private void handleChange(IResourceDelta delta) {
		ShareSession session = ShareClient.getDefault().getActiveSession();
		if(session == null) return;

		IResource resource = delta.getResource();
		SharedProject project = session.getSharedProject(resource.getProject());

		if(project != null) {
			if(project.getSyncState() == SyncState.SYNCING) return; // Project is not done syncing, ignore local changes

			switch(delta.getKind()) {
				case IResourceDelta.ADDED -> {
					if(resource instanceof IFile file) {
						if(file.isDerived()) return;

						Path filePath = file.getLocation().toPath();
						ProjectAndPath path = getProjectAndPath(file);
						ProjectRelativePath relativePath = new ProjectRelativePath(project.getRemoteName(), path.path());
						SharedDocument document = session.getSharedDocument(relativePath);
						if(document != null) {
							// Shouldn't be the case
							System.err.println("Resource was created but is already shared");
							session.removeSharedDocument(relativePath); // Remove the existing shared document
						}

						try {
							document = session.createSharedDocument(relativePath, Files.readAllBytes(filePath));
							sendFullSyncOrChecksum(session.getConnection(), AddressableMessage.BROADCAST_SITE_ID, relativePath, filePath, false);
						} catch (IOException e) {
							e.printStackTrace();
							MessageDialog.openError(null, "Share Client", "Failed to update file: " + e.toString());
							return;
						}
					}

					System.out.println("ADDED " + delta.getResource() + " | Derived: " + delta.getResource().isDerived());
				}
				case IResourceDelta.REMOVED -> {
					if(resource instanceof IFile file) {
						if(file.isDerived()) return;

						ProjectAndPath path = getProjectAndPath(file);
						ProjectRelativePath relativePath = new ProjectRelativePath(project.getRemoteName(), path.path());
						session.removeSharedDocument(relativePath);

						// TODO: send delete message
					}

					System.out.println("REMOVED " + delta.getResource() + " | Derived: " + delta.getResource().isDerived());
				}
				case IResourceDelta.CHANGED -> /* TODO: check for (external) file changes? */ System.out.println("CHANGED " + delta.getResource() + " | Derived: " + delta.getResource().isDerived());
			}
		}

		for(IResourceDelta child : delta.getAffectedChildren()) {
			handleChange(child);
		}
	}

	@Override
	public void stop(BundleContext context) throws Exception {
		plugin = null;
		super.stop(context);
	}

	/**
	 * Returns the shared instance
	 *
	 * @return the shared instance
	 */
	public static ShareClient getDefault() {
		return plugin;
	}

	public void updateView() {
		if (view == null) return;
		Display.getDefault().asyncExec(() -> view.updateActionBars());

		if (activeSession == null) return;
		String[] peerNames = activeSession.getPeers().stream().map(p -> p.name()).toArray(String[]::new);
		Display.getDefault().asyncExec(() -> view.getViewer().setInput(peerNames));
	}

	public ShareSession startSession(String sessionID) {
		String serverURI = getPreferenceStore().getString(ShareClientPreferences.SERVER_URI);
		if (serverURI == null) return null;

		String username = getPreferenceStore().getString(ShareClientPreferences.USERNAME);
		if (username == null || username.isBlank())
			username = "user" + new Random().nextInt(1000);

		WebSocketConnection connection = new WebSocketConnection(URI.create(serverURI), username);
		try {
			connection.connect(sessionID); // TODO: connect to existing session
		} catch (ConnectionException e) {
			e.printStackTrace();
			MessageDialog.openError(null, "Share Client", "Failed to connect to server: " + e);
			return null;
		}

		connection.addListener(this);
		connection.setDisconnectListener(this);

		updateView();
		return activeSession = new ShareSession(connection, sessionID);
	}

	public ShareSession getOrStartSession() {
		if (activeSession == null) {
			startSession(UUID.randomUUID().toString());
		}

		return activeSession;
	}

	public void closeConnection() {
		if (activeSession == null) return;
		ShareSession session = activeSession;
		activeSession = null;
		session.stop();
		updateView();
	}

	public ShareSession getActiveSession() {
		return activeSession;
	}

	public void setView(ShareView view) {
		this.view = view;
	}

	public ShareView getView() {
		return view;
	}

	@Override
	public void onMessage(Message message) {
		Display.getDefault().asyncExec(() -> {
			if (message instanceof PeerJoinMessage join) {
				activeSession.getPeers().add(new Peer(join.peerName(), join.peerSiteID()));
				updateView();
			}

			if(message instanceof PeerLeaveMessage leave) {
				activeSession.getPeers().removeIf(p -> p.siteID() == leave.peerSiteID());
				updateView();
			}

			if (message instanceof FullSyncMessage sync) {
				ProjectRelativePath path;
				try {
					path = ProjectRelativePath.of(sync.documentPath());
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
					return;
				}

				ShareClientDocumentListener listener = partListener.getListener(path);

				IWorkspace workspace = ResourcesPlugin.getWorkspace();
				IWorkspaceRoot workspaceRoot = workspace.getRoot();
				SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
				if(sharedProject == null) {
					// New project, TODO: prompt user to choose location
					IProject project = workspaceRoot.getProject(path.projectName());
					if(project == null) return;

					// TODO: make sure to not overwrite existing non-shared projects
					if (!project.exists()) {
						IProjectDescription description = workspace.newProjectDescription(path.projectName());
						try {
							project.create(description, null);
							project.open(null);
						} catch (CoreException e) {
							e.printStackTrace();
							MessageDialog.openError(null, "Share Client", "Failed to create project: " + e.toString());
							return;
						}
						System.out.println("Created project: " + project);
					}

					sharedProject = new SharedProject(path.projectName(), project);
					activeSession.getSharedProjects().add(sharedProject);
					System.out.println("Received new project: " + path.projectName());
				}

				Path filePath = sharedProject.getLocal().getLocation().toPath().resolve(path.relativePath());
				try {
					if (!Files.exists(filePath)) {
						Files.createDirectories(filePath.getParent());
						Files.createFile(filePath);
					}

					byte[] bytes = new byte[sync.content().size()];
					for(int i = 0; i < bytes.length; i++) {
						bytes[i] = sync.content().get(i).value();
					}

					SharedDocument sharedDocument = activeSession.getOrCreateSharedDocument(path, null /* because the content will be replaced afterwards anyway */);
					sharedDocument.clear();
					for(Char c : sync.content()) sharedDocument.getCharBag().add(c);

					if(listener != null) listener.setIgnoreChanges(true);
					Files.write(filePath, bytes);
					sharedProject.getLocal().refreshLocal(IResource.DEPTH_INFINITE, null);
					if(listener != null) listener.setIgnoreChanges(false);
				} catch (IOException | CoreException e) {
					e.printStackTrace();
					MessageDialog.openError(null, "Share Client", "Failed to update file: " + e.toString());
					return;
				}
			}

			if (message instanceof RequestFullSyncMessage req) {
				Map<ProjectRelativePath, Path> paths = new HashMap<>();
				if (req.documentPath() == null) {
					// Sync entire (shared) workspace
					for (SharedProject project : activeSession.getSharedProjects()) {
						var files = getProjectFiles(project);
						if (files == null) return;
						paths.putAll(files);
					}
				} else {
					ProjectRelativePath path;
					try {
						path = ProjectRelativePath.of(req.documentPath());
					} catch (IllegalArgumentException e) {
						return;
					}

					SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
					if (sharedProject == null) return;

					if (!path.relativePath().isEmpty()) {
						Path projectLocation = sharedProject.getLocal().getLocation().toPath();
						Path filePath = projectLocation.resolve(path.relativePath()).normalize();
						if (!filePath.startsWith(projectLocation)) return;
						paths.put(new ProjectRelativePath(sharedProject.getRemoteName(), path.relativePath()), filePath);
					} else {
						// Sync entire project
						var files = getProjectFiles(sharedProject);
						if (files == null) return;
						paths.putAll(files);
					}
				}

				RemoteConnection connection = activeSession.getConnection();
				System.out.println(paths);
				for (var en : paths.entrySet()) {
					if(!sendFullSyncOrChecksum(connection, req.siteID(), en.getKey(), en.getValue(), false)) return;
				}
			}

			if(message instanceof ChangeMessage change) {
				ProjectRelativePath path;
				try {
					path = ProjectRelativePath.of(change.documentPath());
				}catch(IllegalArgumentException e) {
					return;
				}

				SharedDocument doc = activeSession.getSharedDocument(path); // Doesn't use getOrCreateSharedDocument, because it doesn't make sense to apply a change to a document that wasn't previously shared

				if(doc == null) {
					// TODO: show proper synchronization issue warning, because all received changes should be in previously shared documents
					MessageDialog.openError(null, "Share Client", "Synchronization issue (received change in non-shared document)");
					return;
				}

				doc.onMessage(message);
			}
		});
	}

	@Override
	public void onDisconnect(String reason, boolean remote) {
		MessageDialog.openError(null, "Share Client", "Disconnected (remote = " + remote + "): " + reason);
	}

	/**
	 * Shares a project. Includes sending full syncs to other clients
	 * @param project The project to share
	 */
	public void addSharedProject(IProject project) {
		SharedProject shared = new SharedProject(activeSession.getFreeRemoteName(project.getName()), project);
		activeSession.getSharedProjects().add(shared);

		RemoteConnection connection = activeSession.getConnection();
		for(Map.Entry<ProjectRelativePath, Path> en : getProjectFiles(shared).entrySet()) {
			activeSession.getOrCreateSharedDocument(en.getKey(), () -> {
				try {
					return Files.readAllBytes(en.getValue());
				} catch (IOException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}
			});

			if(!sendFullSyncOrChecksum(connection, AddressableMessage.BROADCAST_SITE_ID, en.getKey(), en.getValue(), false)) return;
		}

		shared.setSyncState(SyncState.SYNCED);
	}

	private boolean sendFullSyncOrChecksum(RemoteConnection connection, int siteID, ProjectRelativePath relativePath, Path filePath, boolean checksum) {
		if (!Files.isRegularFile(filePath)) return true;

		try {
			if(!checksum) {
				SharedDocument document = activeSession.getSharedDocument(relativePath);
				connection.send(new FullSyncMessage(siteID, relativePath.toString(), document.toList()));
			}else {
				byte[] bytes = Files.readAllBytes(filePath);
				connection.send(new ChecksumMessage(siteID, relativePath.toString(), ChecksumUtil.generateSHA256(bytes)));
			}
		} catch (IOException | ConnectionException e) {
			e.printStackTrace();
			MessageDialog.openError(null, "Share Client", "Failed to send file contents: " + e.toString());
			return false;
		}

		return true;
	}

	private ProjectAndPath resolveToProjectAndPath(ProjectRelativePath path) {
		SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
		if(sharedProject == null) return null;
		return new ProjectAndPath(sharedProject.getLocal(), path.relativePath());
	}

	private Path resolveToPath(ProjectRelativePath path) {
		SharedProject sharedProject = activeSession.getSharedProject(path.projectName());
		if(sharedProject == null) return null;
		Path projectLocation = sharedProject.getLocal().getLocation().toPath();
		Path filePath = projectLocation.resolve(path.relativePath()).normalize();
		if (!filePath.startsWith(projectLocation)) return null;
		return filePath;
	}

	private ProjectAndPath getProjectAndPath(IFile file) {
		IProject project = file.getProject();
		Path projectLocation = project.getLocation().toPath();
		return new ProjectAndPath(file.getProject(), projectLocation.relativize(file.getLocation().toPath()).toString());
	}

	private Map<ProjectRelativePath, Path> getProjectFiles(SharedProject project) {
		try {
			Path projectLocation = project.getLocal().getLocation().toPath();
			return Files.walk(projectLocation)
					.filter(Files::isRegularFile)
					.collect(Collectors.toMap(
							p -> new ProjectRelativePath(project.getRemoteName(), projectLocation.relativize(p).toString()),
							Function.identity()));
		} catch (IOException e) {
			e.printStackTrace();
			MessageDialog.openError(null, "Share Client", "Failed to collect project files: " + e.toString());
			return null;
		}
	}

	public ShareClientPartListener getPartListener() {
		return partListener;
	}

	public static void assertOnUIThread() {
		if(!Thread.currentThread().equals(Display.getDefault().getThread())) {
			MessageDialog.openError(null, "Assertion failed", "Not on UI thread");
		}
	}

	@Override
	public void earlyStartup() {
	}

}