/*
 * Copyright 2016-present Facebook, Inc.
 *
 * 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.facebook.buck.parser;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

import com.facebook.buck.cli.BuckConfig;
import com.facebook.buck.cli.FakeBuckConfig;
import com.facebook.buck.io.MorePaths;
import com.facebook.buck.io.ProjectFilesystem;
import com.facebook.buck.model.BuildTarget;
import com.facebook.buck.model.BuildTargetException;
import com.facebook.buck.model.BuildTargetFactory;
import com.facebook.buck.parser.PipelineNodeCache.Cache;
import com.facebook.buck.rules.Cell;
import com.facebook.buck.rules.TestCellBuilder;
import com.facebook.buck.testutil.FakeProjectFilesystem;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;

public class DaemonicCellStateTest {

  private ProjectFilesystem filesystem;
  private Cell rootCell;
  private Cell childCell;
  private DaemonicCellState state;
  private DaemonicCellState childState;

  private void populateDummyRawNode(DaemonicCellState state, BuildTarget target) {
    state.putRawNodesIfNotPresentAndStripMetaEntries(
        target.getCellPath().resolve(target.getBasePath().resolve("BUCK")),
        ImmutableSet.of(
            ImmutableMap.of(
                "name", target.getShortName(),
                "buck.base_path", MorePaths.pathWithUnixSeparators(target.getBasePath()))),
        ImmutableSet.of(),
        ImmutableMap.of(),
        ImmutableMap.of());
  }

  @Before
  public void setUp() throws IOException, InterruptedException {
    filesystem = FakeProjectFilesystem.createJavaOnlyFilesystem();
    Files.createDirectories(filesystem.resolve("../xplat"));
    Files.createFile(filesystem.resolve("../xplat/.buckconfig"));
    BuckConfig config =
        FakeBuckConfig.builder()
            .setFilesystem(filesystem)
            .setSections(ImmutableMap.of("repositories", ImmutableMap.of("xplat", "../xplat")))
            .build();
    rootCell = new TestCellBuilder().setFilesystem(filesystem).setBuckConfig(config).build();
    childCell = rootCell.getCell(filesystem.resolve("../xplat").toAbsolutePath());
    state = new DaemonicCellState(rootCell, 1);
    childState = new DaemonicCellState(childCell, 1);
  }

  @Test
  public void testPutComputedNodeIfNotPresent()
      throws BuildTargetException, IOException, InterruptedException {
    Cache<BuildTarget, Boolean> cache = state.getOrCreateCache(Boolean.class);
    BuildTarget target =
        BuildTargetFactory.newInstance(filesystem.getRootPath(), "//path/to:target");

    // Make sure the cache has a raw node for this target.
    populateDummyRawNode(state, target);

    cache.putComputedNodeIfNotPresent(rootCell, target, false);
    assertEquals(
        "Cached node was not found",
        Optional.of(false),
        cache.lookupComputedNode(rootCell, target));

    assertFalse(cache.putComputedNodeIfNotPresent(rootCell, target, true));
    assertEquals(
        "Previously cached node should not be updated",
        Optional.of(false),
        cache.lookupComputedNode(rootCell, target));
  }

  @Test
  public void testCellNameDoesNotAffectInvalidation()
      throws BuildTargetException, IOException, InterruptedException {
    Cache<BuildTarget, Boolean> cache = childState.getOrCreateCache(Boolean.class);

    Path targetPath = childCell.getRoot().resolve("path/to/BUCK");
    BuildTarget target =
        BuildTargetFactory.newInstance(
            childCell.getFilesystem().getRootPath(), "xplat//path/to:target");

    // Make sure the cache has a raw node for this target.
    populateDummyRawNode(childState, target);

    cache.putComputedNodeIfNotPresent(childCell, target, true);
    assertEquals(Optional.of(true), cache.lookupComputedNode(childCell, target));

    childState.putRawNodesIfNotPresentAndStripMetaEntries(
        targetPath,
        ImmutableSet.of(
            // Forms the target "//path/to:target"
            ImmutableMap.of(
                "buck.base_path", "path/to",
                "name", "target")),
        ImmutableSet.of(),
        ImmutableMap.of(),
        ImmutableMap.of());
    assertEquals("Still only one invalidated node", 1, childState.invalidatePath(targetPath));
    assertEquals(
        "Cell-named target should still be invalidated",
        Optional.empty(),
        cache.lookupComputedNode(childCell, target));
  }
}