/*
    * Copyright (C) 2018, Konrad Windszus <konrad_w@gmx.de> and others
    *
    * This program and the accompanying materials are made available under the
    * terms of the Eclipse Distribution License v. 1.0 which is available at
    * https://www.eclipse.org/org/documents/edl-v10.php.
    *
    * SPDX-License-Identifier: BSD-3-Clause
    */
  package org.eclipse.jgit.internal.transport.http;
  
  import java.io.BufferedReader;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  import java.io.StringReader;
  import java.io.Writer;
  import java.net.HttpCookie;
  import java.net.URL;
  import java.nio.charset.StandardCharsets;
  import java.nio.file.Path;
  import java.text.MessageFormat;
  import java.time.Instant;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.LinkedHashSet;
  import java.util.Set;
  import java.util.concurrent.TimeUnit;
  
  import org.eclipse.jgit.annotations.NonNull;
  import org.eclipse.jgit.annotations.Nullable;
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.internal.storage.file.FileSnapshot;
  import org.eclipse.jgit.internal.storage.file.LockFile;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.storage.file.FileBasedConfig;
  import org.eclipse.jgit.util.FileUtils;
  import org.eclipse.jgit.util.IO;
  import org.eclipse.jgit.util.RawParseUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Wraps all cookies persisted in a <strong>Netscape Cookie File Format</strong>
   * being referenced via the git config <a href=
   * "https://git-scm.com/docs/git-config#git-config-httpcookieFile">http.cookieFile</a>.
   * <p>
   * It will only load the cookies lazily, i.e. before calling
   * {@link #getCookies(boolean)} the file is not evaluated. This class also
   * allows persisting cookies in that file format.
   * <p>
   * In general this class is not thread-safe. So any consumer needs to take care
   * of synchronization!
   *
   * @see <a href="https://curl.se/docs/http-cookies.html">Cookie file format</a>
   * @see <a href="http://www.cookiecentral.com/faq/#3.5">Netscape Cookie File
   *      Format</a>
   * @see <a href=
   *      "https://unix.stackexchange.com/questions/36531/format-of-cookies-when-using-wget">Cookie
   *      format for wget</a>
   * @see <a href=
   *      "https://github.com/curl/curl/blob/07ebaf837843124ee670e5b8c218b80b92e06e47/lib/cookie.c#L745">libcurl
   *      Cookie file parsing</a>
   * @see <a href=
   *      "https://github.com/curl/curl/blob/07ebaf837843124ee670e5b8c218b80b92e06e47/lib/cookie.c#L1417">libcurl
   *      Cookie file writing</a>
   * @see NetscapeCookieFileCache
   */
  public final class NetscapeCookieFile {
  
  	private static final String HTTP_ONLY_PREAMBLE = "#HttpOnly_"; //$NON-NLS-1$
  
  	private static final String COLUMN_SEPARATOR = "\t"; //$NON-NLS-1$
  
  	private static final String LINE_SEPARATOR = "\n"; //$NON-NLS-1$
  
  	/**
  	 * Maximum number of retries to acquire the lock for writing to the
  	 * underlying file.
  	 */
  	private static final int LOCK_ACQUIRE_MAX_RETRY_COUNT = 4;
  
  	/**
  	 * Sleep time in milliseconds between retries to acquire the lock for
  	 * writing to the underlying file.
  	 */
  	private static final int LOCK_ACQUIRE_RETRY_SLEEP = 500;
  
  	private final Path path;
  
  	private FileSnapshot snapshot;
  
  	private byte[] hash;
  
  	private final Instant createdAt;
  
  	private Set<HttpCookie> cookies = null;
 
 	private static final Logger LOG = LoggerFactory
 			.getLogger(NetscapeCookieFile.class);
 
 	/**
 	 * @param path
 	 *            where to find the cookie file
 	 */
 	public NetscapeCookieFile(Path path) {
 		this(path, Instant.now());
 	}
 
 	NetscapeCookieFile(Path path, Instant createdAt) {
 		this.path = path;
 		this.snapshot = FileSnapshot.DIRTY;
 		this.createdAt = createdAt;
 	}
 
 	/**
 	 * Path to the underlying cookie file.
 	 *
 	 * @return the path
 	 */
 	public Path getPath() {
 		return path;
 	}
 
 	/**
 	 * Return all cookies from the underlying cookie file.
 	 *
 	 * @param refresh
 	 *            if {@code true} updates the list from the underlying cookie
 	 *            file if it has been modified since the last read otherwise
 	 *            returns the current transient state. In case the cookie file
 	 *            has never been read before will always read from the
 	 *            underlying file disregarding the value of this parameter.
 	 * @return all cookies (may contain session cookies as well). This does not
 	 *         return a copy of the list but rather the original one. Every
 	 *         addition to the returned list can afterwards be persisted via
 	 *         {@link #write(URL)}. Errors in the underlying file will not lead
 	 *         to exceptions but rather to an empty set being returned and the
 	 *         underlying error being logged.
 	 */
 	public Set<HttpCookie> getCookies(boolean refresh) {
 		if (cookies == null || refresh) {
 			try {
 				byte[] in = getFileContentIfModified();
 				Set<HttpCookie> newCookies = parseCookieFile(in, createdAt);
 				if (cookies != null) {
 					cookies = mergeCookies(newCookies, cookies);
 				} else {
 					cookies = newCookies;
 				}
 				return cookies;
 			} catch (IOException | IllegalArgumentException e) {
 				LOG.warn(
 						MessageFormat.format(
 								JGitText.get().couldNotReadCookieFile, path),
 						e);
 				if (cookies == null) {
 					cookies = new LinkedHashSet<>();
 				}
 			}
 		}
 		return cookies;
 
 	}
 
 	/**
 	 * Parses the given file and extracts all cookie information from it.
 	 *
 	 * @param input
 	 *            the file content to parse
 	 * @param createdAt
 	 *            cookie creation time; used to calculate the maxAge based on
 	 *            the expiration date given within the file
 	 * @return the set of parsed cookies from the given file (even expired
 	 *         ones). If there is more than one cookie with the same name in
 	 *         this file the last one overwrites the first one!
 	 * @throws IOException
 	 *             if the given file could not be read for some reason
 	 * @throws IllegalArgumentException
 	 *             if the given file does not have a proper format
 	 */
 	private static Set<HttpCookie> parseCookieFile(@NonNull byte[] input,
 			@NonNull Instant createdAt)
 			throws IOException, IllegalArgumentException {
 
 		String decoded = RawParseUtils.decode(StandardCharsets.US_ASCII, input);
 
 		Set<HttpCookie> cookies = new LinkedHashSet<>();
 		try (BufferedReader reader = new BufferedReader(
 				new StringReader(decoded))) {
 			String line;
 			while ((line = reader.readLine()) != null) {
 				HttpCookie cookie = parseLine(line, createdAt);
 				if (cookie != null) {
 					cookies.add(cookie);
 				}
 			}
 		}
 		return cookies;
 	}
 
 	private static HttpCookie parseLine(@NonNull String line,
 			@NonNull Instant createdAt) {
 		if (line.isEmpty() || (line.startsWith("#") //$NON-NLS-1$
 				&& !line.startsWith(HTTP_ONLY_PREAMBLE))) {
 			return null;
 		}
 		String[] cookieLineParts = line.split(COLUMN_SEPARATOR, 7);
 		if (cookieLineParts == null) {
 			throw new IllegalArgumentException(MessageFormat
 					.format(JGitText.get().couldNotFindTabInLine, line));
 		}
 		if (cookieLineParts.length < 7) {
 			throw new IllegalArgumentException(MessageFormat.format(
 					JGitText.get().couldNotFindSixTabsInLine,
 					Integer.valueOf(cookieLineParts.length), line));
 		}
 		String name = cookieLineParts[5];
 		String value = cookieLineParts[6];
 		HttpCookie cookie = new HttpCookie(name, value);
 
 		String domain = cookieLineParts[0];
 		if (domain.startsWith(HTTP_ONLY_PREAMBLE)) {
 			cookie.setHttpOnly(true);
 			domain = domain.substring(HTTP_ONLY_PREAMBLE.length());
 		}
 		// strip off leading "."
 		// (https://tools.ietf.org/html/rfc6265#section-5.2.3)
 		if (domain.startsWith(".")) { //$NON-NLS-1$
 			domain = domain.substring(1);
 		}
 		cookie.setDomain(domain);
 		// domain evaluation as boolean flag not considered (i.e. always assumed
 		// to be true)
 		cookie.setPath(cookieLineParts[2]);
 		cookie.setSecure(Boolean.parseBoolean(cookieLineParts[3]));
 
 		long expires = Long.parseLong(cookieLineParts[4]);
 		// Older versions stored milliseconds. This heuristic to detect that
 		// will cause trouble in the year 33658. :-)
 		if (cookieLineParts[4].length() == 13) {
 			expires = TimeUnit.MILLISECONDS.toSeconds(expires);
 		}
 		long maxAge = expires - createdAt.getEpochSecond();
 		if (maxAge <= 0) {
 			return null; // skip expired cookies
 		}
 		cookie.setMaxAge(maxAge);
 		return cookie;
 	}
 
 	/**
 	 * Read the underlying file and return its content but only in case it has
 	 * been modified since the last access.
 	 * <p>
 	 * Internally calculates the hash and maintains {@link FileSnapshot}s to
 	 * prevent issues described as <a href=
 	 * "https://github.com/git/git/blob/master/Documentation/technical/racy-git.txt">"Racy
 	 * Git problem"</a>. Inspired by {@link FileBasedConfig#load()}.
 	 *
 	 * @return the file contents in case the file has been modified since the
 	 *         last access, otherwise {@code null}
 	 * @throws IOException
 	 *             if the file is not found or cannot be read
 	 */
 	private byte[] getFileContentIfModified() throws IOException {
 		final int maxStaleRetries = 5;
 		int retries = 0;
 		File file = getPath().toFile();
 		if (!file.exists()) {
 			LOG.warn(MessageFormat.format(JGitText.get().missingCookieFile,
 					file.getAbsolutePath()));
 			return new byte[0];
 		}
 		while (true) {
 			final FileSnapshot oldSnapshot = snapshot;
 			final FileSnapshot newSnapshot = FileSnapshot.save(file);
 			try {
 				final byte[] in = IO.readFully(file);
 				byte[] newHash = hash(in);
 				if (Arrays.equals(hash, newHash)) {
 					if (oldSnapshot.equals(newSnapshot)) {
 						oldSnapshot.setClean(newSnapshot);
 					} else {
 						snapshot = newSnapshot;
 					}
 				} else {
 					snapshot = newSnapshot;
 					hash = newHash;
 				}
 				return in;
 			} catch (FileNotFoundException e) {
 				throw e;
 			} catch (IOException e) {
 				if (FileUtils.isStaleFileHandle(e)
 						&& retries < maxStaleRetries) {
 					if (LOG.isDebugEnabled()) {
 						LOG.debug(MessageFormat.format(
 								JGitText.get().configHandleIsStale,
 								Integer.valueOf(retries)), e);
 					}
 					retries++;
 					continue;
 				}
 				throw new IOException(MessageFormat
 						.format(JGitText.get().cannotReadFile, getPath()), e);
 			}
 		}
 
 	}
 
 	private static byte[] hash(final byte[] in) {
 		return Constants.newMessageDigest().digest(in);
 	}
 
 	/**
 	 * Writes all the cookies being maintained in the set being returned by
 	 * {@link #getCookies(boolean)} to the underlying file.
 	 * <p>
 	 * Session-cookies will not be persisted.
 	 *
 	 * @param url
 	 *            url for which to write the cookies (important to derive
 	 *            default values for non-explicitly set attributes)
 	 * @throws IOException
 	 *             if the underlying cookie file could not be read or written or
 	 *             a problem with the lock file
 	 * @throws InterruptedException
 	 *             if the thread is interrupted while waiting for the lock
 	 */
 	public void write(URL url) throws IOException, InterruptedException {
 		try {
 			byte[] cookieFileContent = getFileContentIfModified();
 			if (cookieFileContent != null) {
 				LOG.debug("Reading the underlying cookie file '{}' " //$NON-NLS-1$
 						+ "as it has been modified since " //$NON-NLS-1$
 						+ "the last access", //$NON-NLS-1$
 						path);
 				// reread new changes if necessary
 				Set<HttpCookie> cookiesFromFile = NetscapeCookieFile
 						.parseCookieFile(cookieFileContent, createdAt);
 				this.cookies = mergeCookies(cookiesFromFile, cookies);
 			}
 		} catch (FileNotFoundException e) {
 			// ignore if file previously did not exist yet!
 		}
 
 		ByteArrayOutputStream output = new ByteArrayOutputStream();
 		try (Writer writer = new OutputStreamWriter(output,
 				StandardCharsets.US_ASCII)) {
 			write(writer, cookies, url, createdAt);
 		}
 		LockFile lockFile = new LockFile(path.toFile());
 		for (int retryCount = 0; retryCount < LOCK_ACQUIRE_MAX_RETRY_COUNT; retryCount++) {
 			if (lockFile.lock()) {
 				try {
 					lockFile.setNeedSnapshot(true);
 					lockFile.write(output.toByteArray());
 					if (!lockFile.commit()) {
 						throw new IOException(MessageFormat.format(
 								JGitText.get().cannotCommitWriteTo, path));
 					}
 				} finally {
 					lockFile.unlock();
 				}
 				return;
 			}
 			Thread.sleep(LOCK_ACQUIRE_RETRY_SLEEP);
 		}
 		throw new IOException(
 				MessageFormat.format(JGitText.get().cannotLock, lockFile));
 	}
 
 	/**
 	 * Writes the given cookies to the file in the Netscape Cookie File Format
 	 * (also used by curl).
 	 *
 	 * @param writer
 	 *            the writer to use to persist the cookies
 	 * @param cookies
 	 *            the cookies to write into the file
 	 * @param url
 	 *            the url for which to write the cookie (to derive the default
 	 *            values for certain cookie attributes)
 	 * @param createdAt
 	 *            cookie creation time; used to calculate a cookie's expiration
 	 *            time
 	 * @throws IOException
 	 *             if an I/O error occurs
 	 */
 	static void write(@NonNull Writer writer,
 			@NonNull Collection<HttpCookie> cookies, @NonNull URL url,
 			@NonNull Instant createdAt) throws IOException {
 		for (HttpCookie cookie : cookies) {
 			writeCookie(writer, cookie, url, createdAt);
 		}
 	}
 
 	private static void writeCookie(@NonNull Writer writer,
 			@NonNull HttpCookie cookie, @NonNull URL url,
 			@NonNull Instant createdAt) throws IOException {
 		if (cookie.getMaxAge() <= 0) {
 			return; // skip expired cookies
 		}
 		String domain = ""; //$NON-NLS-1$
 		if (cookie.isHttpOnly()) {
 			domain = HTTP_ONLY_PREAMBLE;
 		}
 		if (cookie.getDomain() != null) {
 			domain += cookie.getDomain();
 		} else {
 			domain += url.getHost();
 		}
 		writer.write(domain);
 		writer.write(COLUMN_SEPARATOR);
 		writer.write("TRUE"); //$NON-NLS-1$
 		writer.write(COLUMN_SEPARATOR);
 		String path = cookie.getPath();
 		if (path == null) {
 			path = url.getPath();
 		}
 		writer.write(path);
 		writer.write(COLUMN_SEPARATOR);
 		writer.write(Boolean.toString(cookie.getSecure()).toUpperCase());
 		writer.write(COLUMN_SEPARATOR);
 		final String expirationDate;
 		// whenCreated field is not accessible in HttpCookie
 		expirationDate = String
 				.valueOf(createdAt.getEpochSecond() + cookie.getMaxAge());
 		writer.write(expirationDate);
 		writer.write(COLUMN_SEPARATOR);
 		writer.write(cookie.getName());
 		writer.write(COLUMN_SEPARATOR);
 		writer.write(cookie.getValue());
 		writer.write(LINE_SEPARATOR);
 	}
 
 	/**
 	 * Merge the given sets in the following way. All cookies from
 	 * {@code cookies1} and {@code cookies2} are contained in the resulting set
 	 * which have unique names. If there is a duplicate entry for one name only
 	 * the entry from set {@code cookies1} ends up in the resulting set.
 	 *
 	 * @param cookies1
 	 *            first set of cookies
 	 * @param cookies2
 	 *            second set of cookies
 	 *
 	 * @return the merged cookies
 	 */
 	static Set<HttpCookie> mergeCookies(Set<HttpCookie> cookies1,
 			@Nullable Set<HttpCookie> cookies2) {
 		Set<HttpCookie> mergedCookies = new LinkedHashSet<>(cookies1);
 		if (cookies2 != null) {
 			mergedCookies.addAll(cookies2);
 		}
 		return mergedCookies;
 	}
 }