// Copyright 2019 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 main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"io"
	"os"
	"regexp"
	"strings"
	"unicode"
)

type jsonWhitelist struct {
	Paths               []string
	IgnoreMatchingLines []string
}

type whitelist struct {
	path                string
	ignoreMatchingLines []string
}

func parseWhitelists(whitelists []string, whitelistFiles []string) ([]whitelist, error) {
	var ret []whitelist

	add := func(path string, ignoreMatchingLines []string) {
		for _, x := range ret {
			if x.path == path {
				x.ignoreMatchingLines = append(x.ignoreMatchingLines, ignoreMatchingLines...)
				return
			}
		}

		ret = append(ret, whitelist{
			path:                path,
			ignoreMatchingLines: ignoreMatchingLines,
		})
	}

	for _, file := range whitelistFiles {
		newWhitelists, err := parseWhitelistFile(file)
		if err != nil {
			return nil, err
		}

		for _, w := range newWhitelists {
			add(w.path, w.ignoreMatchingLines)
		}
	}

	for _, s := range whitelists {
		colon := strings.IndexRune(s, ':')
		var ignoreMatchingLines []string
		if colon >= 0 {
			ignoreMatchingLines = []string{s[colon+1:]}
		}
		add(s, ignoreMatchingLines)
	}

	return ret, nil
}

func parseWhitelistFile(file string) ([]whitelist, error) {
	r, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	defer r.Close()

	d := json.NewDecoder(newJSONCommentStripper(r))

	var jsonWhitelists []jsonWhitelist

	err = d.Decode(&jsonWhitelists)

	var whitelists []whitelist
	for _, w := range jsonWhitelists {
		for _, p := range w.Paths {
			whitelists = append(whitelists, whitelist{
				path:                p,
				ignoreMatchingLines: w.IgnoreMatchingLines,
			})
		}
	}

	return whitelists, err
}

func filterModifiedPaths(l [][2]*ZipArtifactFile, whitelists []whitelist) ([][2]*ZipArtifactFile, error) {
outer:
	for i := 0; i < len(l); i++ {
		for _, w := range whitelists {
			if match, err := Match(w.path, l[i][0].Name); err != nil {
				return l, err
			} else if match {
				if match, err := diffIgnoringMatchingLines(l[i][0], l[i][1], w.ignoreMatchingLines); err != nil {
					return l, err
				} else if match || len(w.ignoreMatchingLines) == 0 {
					l = append(l[:i], l[i+1:]...)
					i--
				}
				continue outer
			}
		}
	}

	if len(l) == 0 {
		l = nil
	}

	return l, nil
}

func filterNewPaths(l []*ZipArtifactFile, whitelists []whitelist) ([]*ZipArtifactFile, error) {
outer:
	for i := 0; i < len(l); i++ {
		for _, w := range whitelists {
			if match, err := Match(w.path, l[i].Name); err != nil {
				return l, err
			} else if match && len(w.ignoreMatchingLines) == 0 {
				l = append(l[:i], l[i+1:]...)
				i--
			}
			continue outer
		}
	}

	if len(l) == 0 {
		l = nil
	}

	return l, nil
}

func diffIgnoringMatchingLines(a *ZipArtifactFile, b *ZipArtifactFile, ignoreMatchingLines []string) (match bool, err error) {
	lineMatchesIgnores := func(b []byte) (bool, error) {
		for _, m := range ignoreMatchingLines {
			if match, err := regexp.Match(m, b); err != nil {
				return false, err
			} else if match {
				return match, nil
			}
		}
		return false, nil
	}

	filter := func(z *ZipArtifactFile) ([]byte, error) {
		var ret []byte

		r, err := z.Open()
		if err != nil {
			return nil, err
		}
		s := bufio.NewScanner(r)

		for s.Scan() {
			if match, err := lineMatchesIgnores(s.Bytes()); err != nil {
				return nil, err
			} else if !match {
				ret = append(ret, "\n"...)
				ret = append(ret, s.Bytes()...)
			}
		}

		return ret, nil
	}

	bufA, err := filter(a)
	if err != nil {
		return false, err
	}
	bufB, err := filter(b)
	if err != nil {
		return false, err
	}

	return bytes.Compare(bufA, bufB) == 0, nil
}

func applyWhitelists(diff zipDiff, whitelists []whitelist) (zipDiff, error) {
	var err error

	diff.modified, err = filterModifiedPaths(diff.modified, whitelists)
	if err != nil {
		return diff, err
	}
	diff.onlyInA, err = filterNewPaths(diff.onlyInA, whitelists)
	if err != nil {
		return diff, err
	}
	diff.onlyInB, err = filterNewPaths(diff.onlyInB, whitelists)
	if err != nil {
		return diff, err
	}

	return diff, nil
}

func newJSONCommentStripper(r io.Reader) *jsonCommentStripper {
	return &jsonCommentStripper{
		r: bufio.NewReader(r),
	}
}

type jsonCommentStripper struct {
	r   *bufio.Reader
	b   []byte
	err error
}

func (j *jsonCommentStripper) Read(buf []byte) (int, error) {
	for len(j.b) == 0 {
		if j.err != nil {
			return 0, j.err
		}

		j.b, j.err = j.r.ReadBytes('\n')

		if isComment(j.b) {
			j.b = nil
		}
	}

	n := copy(buf, j.b)
	j.b = j.b[n:]
	return n, nil
}

var commentPrefix = []byte("//")

func isComment(b []byte) bool {
	for len(b) > 0 && unicode.IsSpace(rune(b[0])) {
		b = b[1:]
	}
	return bytes.HasPrefix(b, commentPrefix)
}