// Copyright 2015 Google Inc. All Rights Reserved.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

package com.google.gitiles.doc;

import static javax.servlet.http.HttpServletResponse.SC_NOT_MODIFIED;

import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;

import static org.eclipse.jgit.lib.FileMode.TYPE_FILE;

import static org.eclipse.jgit.lib.FileMode.TYPE_MASK;

import static org.eclipse.jgit.lib.FileMode.TYPE_TREE;

import com.google.common.base.MoreObjects;

import com.google.common.base.Strings;

import com.google.common.base.Throwables;

import com.google.common.hash.Hasher;

import com.google.common.hash.Hashing;

import com.google.common.net.HttpHeaders;

import com.google.gitiles.BaseServlet;

import com.google.gitiles.GitilesAccess;

import com.google.gitiles.GitilesRequestFailureException;

import com.google.gitiles.GitilesRequestFailureException.FailureReason;

import com.google.gitiles.GitilesView;

import com.google.gitiles.Renderer;

import com.google.gitiles.ViewFilter;

import com.google.gitiles.doc.html.StreamHtmlBuilder;

import java.io.IOException;

import java.io.OutputStream;

import java.io.Writer;

import java.util.HashMap;

import java.util.Map;

import javax.annotation.Nullable;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.commonmark.node.Node;

import org.eclipse.jgit.errors.IncorrectObjectTypeException;

import org.eclipse.jgit.errors.LargeObjectException;

import org.eclipse.jgit.http.server.ServletUtils;

import org.eclipse.jgit.lib.Constants;

import org.eclipse.jgit.lib.ObjectId;

import org.eclipse.jgit.lib.ObjectReader;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.revwalk.RevTree;

import org.eclipse.jgit.revwalk.RevWalk;

import org.eclipse.jgit.treewalk.TreeWalk;

public class DocServlet extends BaseServlet {

private static final long serialVersionUID = 1L;

private static final String INDEX_MD = "index.md";

private static final String NAVBAR_MD = "navbar.md";

private static final String SOY_FILE = "Doc.soy";

private static final String SOY_TEMPLATE = "com.google.gitiles.templates.Doc.markdownDoc";

// Generation of ETag logic. Bump this only if DocServlet logic changes

// significantly enough to impact cached pages. Soy template and source

// files are automatically hashed as part of the ETag.

private static final int ETAG_GEN = 5;

private final HtmlSanitizer.Factory htmlSanitizer;

public DocServlet(GitilesAccess.Factory accessFactory, Renderer renderer) {

this(accessFactory, renderer, HtmlSanitizer.DISABLED_FACTORY);

}

public DocServlet(

GitilesAccess.Factory accessFactory, Renderer renderer, HtmlSanitizer.Factory htmlSanitizer) {

super(renderer, accessFactory);

this.htmlSanitizer = htmlSanitizer;

}

@Override

protected void doGetHtml(HttpServletRequest req, HttpServletResponse res) throws IOException {

MarkdownConfig cfg = MarkdownConfig.get(getAccess(req).getConfig());

if (!cfg.render) {

throw new GitilesRequestFailureException(FailureReason.MARKDOWN_NOT_ENABLED);

}

GitilesView view = ViewFilter.getView(req);

Repository repo = ServletUtils.getRepository(req);

try (RevWalk rw = new RevWalk(repo)) {

ObjectReader reader = rw.getObjectReader();

String path = view.getPathPart();

RevTree root;

try {

root = rw.parseTree(view.getRevision().getId());

} catch (IncorrectObjectTypeException e) {

throw new GitilesRequestFailureException(FailureReason.INCORRECT_OBJECT_TYPE, e);

}

MarkdownFile srcmd = findFile(rw, root, path);

if (srcmd == null) {

throw new GitilesRequestFailureException(FailureReason.OBJECT_NOT_FOUND);

}

MarkdownFile navmd = findNavbar(rw, root, path);

String curEtag = etag(srcmd, navmd);

if (etagMatch(req, curEtag)) {

res.setStatus(SC_NOT_MODIFIED);

return;

}

view = view.toBuilder().setPathPart(srcmd.path).build();

try {

srcmd.read(reader, cfg);

if (navmd != null) {

navmd.read(reader, cfg);

}

} catch (LargeObjectException.ExceedsLimit e) {

fileTooBig(res, view);

return;

}

MarkdownToHtml.Builder fmt =

MarkdownToHtml.builder()

.setConfig(cfg)

.setGitilesView(view)

.setRequestUri(req.getRequestURI())

.setReader(reader)

.setRootTree(root)

.setHtmlSanitizer(htmlSanitizer.create(req));

Navbar navbar = createNavbar(cfg, fmt, navmd);

res.setHeader(HttpHeaders.ETAG, curEtag);

showDoc(req, res, view, fmt, navbar, srcmd);

}

}

private static boolean etagMatch(HttpServletRequest req, String etag) {

String reqEtag = req.getHeader(HttpHeaders.IF_NONE_MATCH);

return reqEtag != null && reqEtag.equals(etag);

}

private String etag(MarkdownFile srcmd, @Nullable MarkdownFile navmd) {

byte[] b = new byte[Constants.OBJECT_ID_LENGTH];

Hasher h = Hashing.murmur3_128().newHasher();

h.putInt(ETAG_GEN);

renderer.getTemplateHash(SOY_FILE).writeBytesTo(b, 0, b.length);

h.putBytes(b);

if (navmd != null) {

navmd.id.copyRawTo(b, 0);

h.putBytes(b);

}

srcmd.id.copyRawTo(b, 0);

h.putBytes(b);

return h.hash().toString();

}

private @Nullable MarkdownFile findNavbar(RevWalk rw, RevTree root, String path)

throws IOException {

if (!Strings.isNullOrEmpty(path)) {

// Traverse up the path until we find a NAVBAR_MD.

StringBuilder pathRemaining = new StringBuilder(path);

while (pathRemaining.length() > 0) {

int lastPathSeparatorIndex = pathRemaining.lastIndexOf("/");

pathRemaining.setLength(lastPathSeparatorIndex + 1);

MarkdownFile navmd = findFile(rw, root, pathRemaining.toString() + NAVBAR_MD);

if (navmd != null) {

return navmd;

}

pathRemaining.setLength(Math.max(lastPathSeparatorIndex, 0));

}

return null;

}

return findFile(rw, root, NAVBAR_MD);

}

private void showDoc(

HttpServletRequest req,

HttpServletResponse res,

GitilesView view,

MarkdownToHtml.Builder fmt,

Navbar navbar,

MarkdownFile srcFile)

throws IOException {

Map<String, Object> data = new HashMap<>();

data.putAll(navbar.toSoyData());

MarkdownConfig cfg = navbar.getConfig();

Node doc = GitilesMarkdown.parse(cfg, srcFile.consumeContent());

data.put("pageTitle", pageTitle(doc, srcFile));

if (view.getType() != GitilesView.Type.ROOTED_DOC) {

data.put("sourceUrl", GitilesView.show().copyFrom(view).toUrl());

data.put("logUrl", GitilesView.log().copyFrom(view).toUrl());

data.put("blameUrl", GitilesView.blame().copyFrom(view).toUrl());

}

if (cfg.analyticsId != null) {

data.put("analyticsId", cfg.analyticsId);

}

try (OutputStream out = startRenderCompressedStreamingHtml(req, res, SOY_TEMPLATE, data)) {

Writer w = newWriter(out, res);

fmt.setConfig(cfg)

.setFilePath(srcFile.path)

.build()

.renderToHtml(new StreamHtmlBuilder(w), doc);

w.flush();

} catch (RuntimeIOException e) {

Throwables.throwIfInstanceOf(e.getCause(), IOException.class);

throw e;

}

}

private static Navbar createNavbar(

MarkdownConfig cfg, MarkdownToHtml.Builder fmt, @Nullable MarkdownFile navFile) {

Navbar navbar = new Navbar().setConfig(cfg);

if (navFile != null) {

navbar

.setFormatter(fmt.setFilePath(navFile.path).build())

.setMarkdown(navFile.consumeContent());

}

return navbar;

}

private static String pageTitle(Node doc, MarkdownFile srcFile) {

String title = MarkdownUtil.getTitle(doc);

return MoreObjects.firstNonNull(title, srcFile.path);

}

private static @Nullable MarkdownFile findFile(RevWalk rw, RevTree root, String path)

throws IOException {

if (Strings.isNullOrEmpty(path)) {

path = INDEX_MD;

}

ObjectReader reader = rw.getObjectReader();

try (TreeWalk tw = TreeWalk.forPath(reader, path, root)) {

if (tw == null) {

return null;

}

if ((tw.getRawMode(0) & TYPE_MASK) == TYPE_TREE) {

if (findIndexFile(tw)) {

path = tw.getPathString();

} else {

return null;

}

}

if ((tw.getRawMode(0) & TYPE_MASK) == TYPE_FILE) {

if (!path.endsWith(".md")) {

return null;

}

return new MarkdownFile(path, tw.getObjectId(0));

}

return null;

}

}

private static boolean findIndexFile(TreeWalk tw) throws IOException {

tw.enterSubtree();

while (tw.next()) {

if ((tw.getRawMode(0) & TYPE_MASK) == TYPE_FILE && INDEX_MD.equals(tw.getNameString())) {

return true;

}

}

return false;

}

private static void fileTooBig(HttpServletResponse res, GitilesView view) throws IOException {

if (view.getType() == GitilesView.Type.ROOTED_DOC) {

throw new GitilesRequestFailureException(FailureReason.OBJECT_TOO_LARGE);

}

res.sendRedirect(GitilesView.show().copyFrom(view).toUrl());

}

private static class MarkdownFile {

final String path;

final ObjectId id;

byte[] content;

MarkdownFile(String path, ObjectId id) {

this.path = path;

this.id = id;

}

void read(ObjectReader reader, MarkdownConfig cfg) throws IOException {

content = reader.open(id, OBJ_BLOB).getCachedBytes(cfg.inputLimit);

}

byte[] consumeContent() {

byte[] c = content;

content = null;

return c;

}

}

}