package main

import (
	"bytes"
	"fmt"
	"io"
	"log"
	"net/http"
	"time"

	. "gopkg.in/check.v1"
)

type AlbumCoverCacheSuite struct {
	cache *AlbumCoverCache
}

var _ = Suite(&AlbumCoverCacheSuite{})

// a simple HTTPGetter that will never GET anything
type errorGetter struct{}

func (g *errorGetter) Get(URL string) (*http.Response, error) {
	return nil, fmt.Errorf("I will always have an error")
}

func (s *AlbumCoverCacheSuite) SetUpSuite(c *C) {
	s.cache = NewAlbumCoverCache(c.MkDir(), 10, 10*time.Second)
	s.cache.getter = testGetter

	for _, a := range albumsDataTest {
		s.cache.RegisterCover(a.ID, a.CoverURL)
	}
}

func (s *AlbumCoverCacheSuite) TestCanFetchCache(c *C) {

	var resData = []bytes.Buffer{}
	start := time.Now()
	for _, a := range albumsDataTest {
		cover, _, err := s.cache.GetCover(a.ID)
		var buf bytes.Buffer
		if c.Check(err, IsNil) == true {
			_, err := io.Copy(&buf, cover)
			c.Check(err, IsNil)
			c.Check(cover.Close(), IsNil)
		}
		resData = append(resData, buf)
	}

	s.cache.getter = &errorGetter{}

	// now we check that we get it again, but from the disk, not
	// hitting the web
	for i, a := range albumsDataTest {
		cover, _, err := s.cache.GetCover(a.ID)
		var buf bytes.Buffer
		if c.Check(err, IsNil) == true {
			_, err := io.Copy(&buf, cover)
			if c.Check(err, IsNil) == true {
				c.Check(buf.Bytes(), DeepEquals, resData[i].Bytes())
			}
			c.Check(cover.Close(), IsNil)
		}
	}

	// now if we it the TTL, we will reftech and get error
	s.cache.TTL = 0

	for _, a := range albumsDataTest {
		cover, _, err := s.cache.GetCover(a.ID)
		c.Check(cover, IsNil)
		c.Check(err, ErrorMatches, "I will always have an error")
	}
	log.Printf("%s: %s", c.TestName(), time.Since(start))
}