/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.maven.scm.provider.git.gitexe.command.changelog;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.TimeZone;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.maven.scm.ChangeFile;
import org.apache.maven.scm.ChangeSet;
import org.apache.maven.scm.ScmFileStatus;
import org.apache.maven.scm.util.AbstractConsumer;

/**
 * @author <a href="mailto:struberg@yahoo.de">Mark Struberg</a>
 * @author Olivier Lamy
 *
 */
public class GitChangeLogConsumer extends AbstractConsumer {
    /**
     * Date formatter for git timestamp
     * we use iso format cli git log --date=iso sample : 2008-08-06 01:37:18 +0200
     */
    private static final String GIT_TIMESTAMP_PATTERN = "yyyy-MM-dd HH:mm:ss Z";

    /**
     * State machine constant: expecting header
     */
    private static final int STATUS_GET_HEADER = 1;

    /**
     * State machine constant: expecting author information
     */
    private static final int STATUS_GET_AUTHOR = 2;

    /**
     * State machine constant: expecting parent hash information
     */
    private static final int STATUS_RAW_TREE = 21;

    /**
     * State machine constant: expecting parent hash information
     */
    private static final int STATUS_RAW_PARENT = 22;

    /**
     * State machine constant: expecting author name, email and timestamp information
     */
    private static final int STATUS_RAW_AUTHOR = 23;

    /**
     * State machine constant: expecting committer name, email and timestamp information
     */
    private static final int STATUS_RAW_COMMITTER = 24;

    /**
     * State machine constant: expecting date information
     */
    private static final int STATUS_GET_DATE = 3;

    /**
     * State machine constant: expecting file information
     */
    private static final int STATUS_GET_FILE = 4;

    /**
     * State machine constant: expecting comments
     */
    private static final int STATUS_GET_COMMENT = 5;

    /**
     * The pattern used to match git header lines
     */
    private static final Pattern HEADER_PATTERN = Pattern.compile("^commit ([A-Fa-f0-9]+)(?: \\((.*)\\))?$");

    /**
     * The pattern used to match git author lines
     */
    private static final Pattern AUTHOR_PATTERN = Pattern.compile("^Author: (.*)");

    /**
     * The pattern used to match git tree hash lines (raw mode)
     */
    private static final Pattern RAW_TREE_PATTERN = Pattern.compile("^tree ([A-Fa-f0-9]+)");

    /**
     * The pattern used to match git parent hash lines (raw mode)
     */
    private static final Pattern RAW_PARENT_PATTERN = Pattern.compile("^parent ([A-Fa-f0-9]+)");

    /**
     * The pattern used to match git author lines (raw mode)
     */
    private static final Pattern RAW_AUTHOR_PATTERN = Pattern.compile("^author (.+ <.+>) ([0-9]+) (.*)");

    /**
     * The pattern used to match git author lines (raw mode)
     */
    private static final Pattern RAW_COMMITTER_PATTERN = Pattern.compile("^committer (.+ <.+>) ([0-9]+) (.*)");

    /**
     * The pattern used to match git date lines
     */
    private static final Pattern DATE_PATTERN = Pattern.compile("^Date:\\s*(.*)");

    /**
     * The pattern used to match git file lines
     */
    private static final Pattern FILE_PATTERN =
            Pattern.compile("^:\\d* \\d* [A-Fa-f0-9]*\\.* [A-Fa-f0-9]*\\.* ([A-Z])[0-9]*\\t([^\\t]*)(\\t(.*))?");

    /**
     * Current status of the parser
     */
    private int status = STATUS_GET_HEADER;

    /**
     * List of change log entries
     */
    private final List<ChangeSet> entries = new ArrayList<>();

    /**
     * The current log entry being processed by the parser
     */
    private ChangeSet currentChange;

    /**
     * The current revision of the entry being processed by the parser
     */
    private String currentRevision;

    /**
     * The current comment of the entry being processed by the parser
     */
    private StringBuilder currentComment;

    private final String userDateFormat;

    /**
     * Default constructor.
     */
    public GitChangeLogConsumer(String userDateFormat) {
        this.userDateFormat = userDateFormat;
    }

    public List<ChangeSet> getModifications() {
        // this is needed since the processFile does not always get a the end-sequence correctly.
        processGetFile("");

        return entries;
    }

    // ----------------------------------------------------------------------
    // StreamConsumer Implementation
    // ----------------------------------------------------------------------

    /**
     * {@inheritDoc}
     */
    public void consumeLine(String line) {
        switch (status) {
            case STATUS_GET_HEADER:
                processGetHeader(line);
                break;
            case STATUS_GET_AUTHOR:
                processGetAuthor(line);
                break;
            case STATUS_GET_DATE:
                processGetDate(line, null);
                break;
            case STATUS_GET_COMMENT:
                processGetComment(line);
                break;
            case STATUS_GET_FILE:
                processGetFile(line);
                break;
            case STATUS_RAW_TREE:
                processGetRawTree(line);
                break;
            case STATUS_RAW_PARENT:
                processGetRawParent(line);
                break;
            case STATUS_RAW_AUTHOR:
                processGetRawAuthor(line);
                break;
            case STATUS_RAW_COMMITTER:
                processGetRawCommitter(line);
                break;
            default:
                throw new IllegalStateException("Unknown state: " + status);
        }
    }

    // ----------------------------------------------------------------------
    //
    // ----------------------------------------------------------------------

    /**
     * Process the current input line in the GET_HEADER state.  The
     * author, date, and the revision of the entry are gathered.  Note,
     * Git does not have per-file revisions, instead, the entire
     * branch is given a single revision number, which is also used for
     * the revision number of each file.
     *
     * @param line A line of text from the git log output
     */
    private void processGetHeader(String line) {
        Matcher matcher = HEADER_PATTERN.matcher(line);
        if (!matcher.matches()) {
            return;
        }

        currentRevision = matcher.group(1);

        currentChange = new ChangeSet();

        currentChange.setRevision(currentRevision);

        // Extract the tags (if present)
        String tagList = matcher.group(2);
        if (tagList != null) {
            String[] rawTags = tagList.split(",");
            for (String rawTag : rawTags) {
                String[] tagParts = rawTag.trim().split(":");
                if (tagParts.length == 2 && "tag".equals(tagParts[0])) {
                    currentChange.addTag(tagParts[1].trim());
                }
            }
        }

        status = STATUS_GET_AUTHOR;
    }

    /**
     * Process the current input line in the STATUS_GET_AUTHOR state.  This
     * state gathers all of the author information that are part of a log entry.
     *
     * @param line a line of text from the git log output
     */
    private void processGetAuthor(String line) {
        // this autodetects 'raw' format
        if (RAW_TREE_PATTERN.matcher(line).matches()) {
            status = STATUS_RAW_TREE;
            processGetRawTree(line);
            return;
        }

        Matcher matcher = AUTHOR_PATTERN.matcher(line);
        if (!matcher.matches()) {
            return;
        }
        String author = matcher.group(1);

        currentChange.setAuthor(author);

        status = STATUS_GET_DATE;
    }

    /**
     * Process the current input line in the STATUS_RAW_TREE state.  This
     * state gathers tree hash part of a log entry.
     *
     * @param line a line of text from the git log output
     */
    private void processGetRawTree(String line) {
        if (!RAW_TREE_PATTERN.matcher(line).matches()) {
            return;
        }
        // here we could set treeHash if it appears in the model: currentChange.setTreeHash( matcher.group( 1 ) );
        status = STATUS_RAW_PARENT;
    }

    /**
     * Process the current input line in the STATUS_RAW_PARENT state.  This
     * state gathers parent revisions of a log entry.
     *
     * @param line a line of text from the git log output
     */
    private void processGetRawParent(String line) {
        Matcher matcher = RAW_PARENT_PATTERN.matcher(line);
        if (!matcher.matches()) {
            status = STATUS_RAW_AUTHOR;
            processGetRawAuthor(line);
            return;
        }
        String parentHash = matcher.group(1);

        addParentRevision(parentHash);
    }

    /**
     * In git log, both parent and merged revisions are called parent. Fortunately, the real parent comes first in the
     * log. This method takes care of the difference.
     *
     * @param hash -
     */
    private void addParentRevision(String hash) {
        if (currentChange.getParentRevision() == null) {
            currentChange.setParentRevision(hash);
        } else {
            currentChange.addMergedRevision(hash);
        }
    }

    /**
     * Process the current input line in the STATUS_RAW_AUTHOR state.  This
     * state gathers all the author information of a log entry.
     *
     * @param line a line of text from the git log output
     */
    private void processGetRawAuthor(String line) {
        Matcher matcher = RAW_AUTHOR_PATTERN.matcher(line);
        if (!matcher.matches()) {
            return;
        }
        String author = matcher.group(1);
        currentChange.setAuthor(author);

        String datestring = matcher.group(2);
        String tz = matcher.group(3);

        // with --format=raw option (which gets us to this methods), date is always in seconds since beginning of time
        // even explicit --date=iso is ignored, so we ignore both userDateFormat and GIT_TIMESTAMP_PATTERN here
        Calendar c = Calendar.getInstance(TimeZone.getTimeZone(tz));
        c.setTimeInMillis(Long.parseLong(datestring) * 1000);
        currentChange.setDate(c.getTime());

        status = STATUS_RAW_COMMITTER;
    }

    /**
     * Process the current input line in the STATUS_RAW_AUTHOR state.  This
     * state gathers all the committer information of a log entry.
     *
     * @param line a line of text from the git log output
     */
    private void processGetRawCommitter(String line) {
        if (!RAW_COMMITTER_PATTERN.matcher(line).matches()) {
            return;
        }
        // here we could set committer and committerDate, the same way as in processGetRawAuthor
        status = STATUS_GET_COMMENT;
    }

    /**
     * Process the current input line in the STATUS_GET_DATE state.  This
     * state gathers all of the date information that are part of a log entry.
     *
     * @param line a line of text from the git log output
     */
    private void processGetDate(String line, Locale locale) {
        Matcher matcher = DATE_PATTERN.matcher(line);
        if (!matcher.matches()) {
            return;
        }

        String datestring = matcher.group(1);

        Date date = parseDate(datestring.trim(), userDateFormat, GIT_TIMESTAMP_PATTERN, locale);

        currentChange.setDate(date);

        status = STATUS_GET_COMMENT;
    }

    /**
     * Process the current input line in the GET_COMMENT state.  This
     * state gathers all of the comments that are part of a log entry.
     *
     * @param line a line of text from the git log output
     */
    private void processGetComment(String line) {
        if (line.length() < 4) {
            if (currentComment == null) {
                currentComment = new StringBuilder();
            } else {
                currentChange.setComment(currentComment.toString());
                status = STATUS_GET_FILE;
            }
        } else {
            if (currentComment.length() > 0) {
                currentComment.append('\n');
            }

            currentComment.append(line.substring(4));
        }
    }

    /**
     * Process the current input line in the GET_FILE state.  This state
     * adds each file entry line to the current change log entry.  Note,
     * the revision number for the entire entry is used for the revision
     * number of each file.
     *
     * @param line A line of text from the git log output
     */
    private void processGetFile(String line) {
        if (line.length() == 0) {
            if (currentChange != null) {
                entries.add(currentChange);
            }

            resetChangeLog();

            status = STATUS_GET_HEADER;
        } else {
            Matcher matcher = FILE_PATTERN.matcher(line);
            if (!matcher.matches()) {
                return;
            }
            final String actionChar = matcher.group(1);
            // action is currently not used
            final ScmFileStatus action;
            String name = matcher.group(2);
            String originalName = null;
            String originalRevision = null;
            if ("A".equals(actionChar)) {
                action = ScmFileStatus.ADDED;
            } else if ("M".equals(actionChar)) {
                action = ScmFileStatus.MODIFIED;
            } else if ("D".equals(actionChar)) {
                action = ScmFileStatus.DELETED;
            } else if ("R".equals(actionChar)) {
                action = ScmFileStatus.RENAMED;
                originalName = name;
                name = matcher.group(4);
                originalRevision = currentChange.getParentRevision();
            } else if ("C".equals(actionChar)) {
                action = ScmFileStatus.COPIED;
                originalName = name;
                name = matcher.group(4);
                originalRevision = currentChange.getParentRevision();
            } else {
                action = ScmFileStatus.UNKNOWN;
            }

            final ChangeFile changeFile = new ChangeFile(name, currentRevision);
            changeFile.setAction(action);
            changeFile.setOriginalName(originalName);
            changeFile.setOriginalRevision(originalRevision);
            currentChange.addFile(changeFile);
        }
    }

    private void resetChangeLog() {
        currentComment = null;
        currentChange = null;
    }
}