// 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 status

import (
 "reflect"
 "testing"
 "time"
)

type testCriticalPath struct {
 *CriticalPath
 Counts

 actions map[int]*Action
}

type testClock time.Time

func (t testClock) Now() time.Time { return time.Time(t) }

func (t *testCriticalPath) start(id int, startTime time.Duration, outputs, inputs []string) {
 t.clock = testClock(time.Unix(0, 0).Add(startTime))
 action := &Action{
  Description: outputs[0],
  Outputs:     outputs,
  Inputs:      inputs,
 }

 t.actions[id] = action
 t.StartAction(action)
}

func (t *testCriticalPath) finish(id int, endTime time.Duration) {
 t.clock = testClock(time.Unix(0, 0).Add(endTime))
 t.FinishAction(t.actions[id])
}

func TestCriticalPath(t *testing.T) {
 tests := []struct {
  name     string
  msgs     func(*testCriticalPath)
  want     []string
  wantTime time.Duration
 }{
  {
   name: "empty",
   msgs: func(cp *testCriticalPath) {},
  },
  {
   name: "duplicate",
   msgs: func(cp *testCriticalPath) {
    cp.start(0, 0, []string{"a"}, nil)
    cp.start(1, 0, []string{"a"}, nil)
    cp.finish(0, 1000)
    cp.finish(0, 2000)
   },
   want:     []string{"a"},
   wantTime: 1000,
  },
  {
   name: "linear",
   //  a
   //  |
   //  b
   //  |
   //  c
   msgs: func(cp *testCriticalPath) {
    cp.start(0, 0, []string{"a"}, nil)
    cp.finish(0, 1000)
    cp.start(1, 1000, []string{"b"}, []string{"a"})
    cp.finish(1, 2000)
    cp.start(2, 3000, []string{"c"}, []string{"b"})
    cp.finish(2, 4000)
   },
   want:     []string{"c", "b", "a"},
   wantTime: 3000,
  },
  {
   name: "diamond",
   //  a
   //  |\
   //  b c
   //  |/
   //  d
   msgs: func(cp *testCriticalPath) {
    cp.start(0, 0, []string{"a"}, nil)
    cp.finish(0, 1000)
    cp.start(1, 1000, []string{"b"}, []string{"a"})
    cp.start(2, 1000, []string{"c"}, []string{"a"})
    cp.finish(1, 2000)
    cp.finish(2, 3000)
    cp.start(3, 3000, []string{"d"}, []string{"b", "c"})
    cp.finish(3, 4000)
   },
   want:     []string{"d", "c", "a"},
   wantTime: 4000,
  },
  {
   name: "multiple",
   //  a d
   //  | |
   //  b e
   //  |
   //  c
   msgs: func(cp *testCriticalPath) {
    cp.start(0, 0, []string{"a"}, nil)
    cp.start(3, 0, []string{"d"}, nil)
    cp.finish(0, 1000)
    cp.finish(3, 1000)
    cp.start(1, 1000, []string{"b"}, []string{"a"})
    cp.start(4, 1000, []string{"e"}, []string{"d"})
    cp.finish(1, 2000)
    cp.start(2, 2000, []string{"c"}, []string{"b"})
    cp.finish(2, 3000)
    cp.finish(4, 4000)

   },
   want:     []string{"e", "d"},
   wantTime: 4000,
  },
 }
 for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
   cp := &testCriticalPath{
    CriticalPath: NewCriticalPath(),
    actions:      make(map[int]*Action),
   }

   tt.msgs(cp)

   criticalPath, _, _ := cp.CriticalPath.criticalPath()

   var descs []string
   for _, x := range criticalPath {
    descs = append(descs, x.action.Description)
   }

   if !reflect.DeepEqual(descs, tt.want) {
    t.Errorf("criticalPath.criticalPath() = %v, want %v", descs, tt.want)
   }

   var gotTime time.Duration
   if len(criticalPath) > 0 {
    gotTime = criticalPath[0].cumulativeDuration
   }
   if gotTime != tt.wantTime {
    t.Errorf("cumulativeDuration[0].cumulativeDuration = %v, want %v", gotTime, tt.wantTime)
   }
  })
 }
}