package fitbit

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

func TestParseSleep(t *testing.T) {
	ctx := context.Background()

	input := `{
    "dateOfSleep": "2017-04-02",
    "duration": 42000,
    "efficiency": 42,
    "isMainSleep": true,
    "levels": {
        "summary": {
            "deep": {
                "count": 42,
                "minutes": 42,
                "thirtyDayAvgMinutes": 42
            },
            "light": {
                "count": 42,
                "minutes": 42,
                "thirtyDayAvgMinutes": 42
            },
            "rem": {
                "count": 42,
                "minutes": 42,
                "thirtyDayAvgMinutes": 42
            },
            "wake": {
                "count": 42,
                "minutes": 42,
                "thirtyDayAvgMinutes": 42
            }
        },
        "data": [
            {
                "datetime": "2017-04-01T23:58:30.000",
                "level": "wake",
                "seconds": 1080
            },
            {
                "datetime": "2017-04-02T00:16:30.000",
                "level": "rem",
                "seconds": 2000
            }
        ],
        "shortData": [
            {
                "datetime": "2017-04-01T23:58:30.000",
                "level": "wake",
                "seconds": 1080
            },
            {
                "datetime": "2017-04-02T00:16:30.000",
                "level": "deep",
                "seconds": 100
            },
            {
                "datetime": "2017-04-02T00:18:10.000",
                "level": "rem",
                "seconds": 1900
            }
        ]
    },
    "logId": 42,
    "minutesAfterWakeup": 42,
    "minutesAsleep": 42,
    "minutesAwake": 42,
    "minutesToFallAsleep": 0,
    "startTime": "2017-04-01T23:58:30.000",
    "timeInBed": 42,
    "type": "stages"
}`

	want := &Sleep{
		Stages: []SleepStage{
			SleepStage{
				StartTime: time.Date(2017, time.April, 1, 23, 58, 30, 0, time.UTC),
				EndTime:   time.Date(2017, time.April, 2, 0, 16, 30, 0, time.UTC),
				Level:     SleepLevelWake,
			},
			SleepStage{
				StartTime: time.Date(2017, time.April, 2, 0, 16, 30, 0, time.UTC),
				EndTime:   time.Date(2017, time.April, 2, 0, 18, 10, 0, time.UTC),
				Level:     SleepLevelDeep,
			},
			SleepStage{
				StartTime: time.Date(2017, time.April, 2, 0, 18, 10, 0, time.UTC),
				EndTime:   time.Date(2017, time.April, 2, 0, 49, 50, 0, time.UTC),
				Level:     SleepLevelREM,
			},
		},
	}

	got, err := parseSleep(ctx, []byte(input), time.UTC)
	if err != nil {
		t.Errorf("parseSleep() = %v", err)
	}

	for i, stg := range got.Stages {
		t.Logf("got.Stages[%d] = %+v", i, stg)
	}
	for i, stg := range want.Stages {
		t.Logf("want.Stages[%d] = %+v", i, stg)
	}

	if !reflect.DeepEqual(got, want) {
		t.Errorf("parseSleep() = %+v, want %+v", got, want)
	}
}