type httpValueRangeRequest struct {
	manager       *SheetManager
	ranges        string
	spreadsheetID string
}
func (r *httpValueRangeRequest) Do() *sheets.ValueRange {
	r.manager.refreshToken()
	req := r.manager.service.Spreadsheets.Values.Get(r.spreadsheetID, r.ranges)
	req.Header().Add("Authorization", "Bearer "+r.manager.token.AccessToken)
	valueRange, err := req.Do()
	if err != nil {
		panic(err)
	}
	return valueRange
}

// deleteSpreadsheet deletes spreadsheet file with `spreadsheetId`
// Returns true if deleted(status code 20X)
//         false if else
// https://stackoverflow.com/questions/46836393/how-do-i-delete-a-spreadsheet-file-using-google-spreadsheets-api
// https://stackoverflow.com/questions/46310113/consume-a-delete-endpoint-from-golang
// api count: 1
func (m *SheetManager) deleteSpreadsheet(spreadsheetID string) bool {
	resp := newURLRequest(m, delete, fmt.Sprintf("https://www.googleapis.com/drive/v3/files/%s", spreadsheetID)).Do()
	return resp.StatusCode/100 == 2
}

r.manager.refreshToken()
batchRequest := &sheets.BatchUpdateValuesRequest{}
batchRequest.IncludeValuesInResponse = true
batchRequest.ValueInputOption = "RAW"
batchRequest.Data = make([]*sheets.ValueRange, 2)
rangeValues := &sheets.ValueRange{}
rangeValues.Range = r.rangeValues
rangeValues.Values = r.updatingValues

rangeRows := &sheets.ValueRange{}
rangeRows.Range = r.rangeRows
rangeRows.Values = r.updatingRows

batchRequest.Data[0] = rangeValues
batchRequest.Data[1] = rangeRows

req := r.manager.service.Spreadsheets.Values.BatchUpdate(r.spreadsheetID, batchRequest)
req.Header().Add("Authorization", "Bearer "+r.manager.token.AccessToken)
updatedRange, err := req.Do()

r.manager.refreshToken()
req := r.manager.service.Spreadsheets.Values.Get(r.spreadsheetID, r.ranges)
req.Header().Add("Authorization", "Bearer "+r.manager.token.AccessToken)
valueRange, err := req.Do()
if err != nil {
    panic(err)
}
return valueRange

// download all data
data, scheme := table.selectData(-1)
if data == nil {
	return nil
}

// delete if predicate==true
newData := make([]interface{}, 0)
deletedIndex := make([]int64, 0)
for i, values := range data {
	if deleteThis(values) {
		// add to deleted index
		deletedIndex = append(deletedIndex, int64(i))
	} else {
		newData = append(newData, values)
	}
}

if len(deletedIndex) == 0 {
	return nil
}

// update deleted data
table.upsertIf(newData, false)

func (m *SheetManager) enqueueAPIUsage(task int64, blockIfQuota bool) {
    // https://hakurei.tistory.com/193 [Reimu's Development Blog])
    // Google uses Pacific Time Zone
	now := time.Now().In(time.FixedZone("GMT-7", -7*60*60)).Unix()
	if m.lastQuotaTime == 0 {
		m.lastQuotaTime = (now / 100) * 100
	} else if m.lastQuotaTime+100 <= now {
		m.lastQuotaTime = (now / 100) * 100
	}
	// check if api usage is enough
	if m.apiUsage >= 90 {
		if blockIfQuota {
			timeToWait := time.Second * time.Duration(m.lastQuotaTime+100-now)
			fmt.Printf("[%v] Pending %v seconds, api usage: %v\n", now, m.lastQuotaTime+100-now, m.apiUsage)
			<-time.NewTimer(timeToWait).C
		}

        // Reset quota
		now = time.Now().In(time.FixedZone("GMT-7", -7*60*60)).Unix()
		fmt.Printf("[%v] Resetting quota\n", now)
		m.lastQuotaTime += 100
		m.apiUsage = 0
	}
	m.apiUsage += task
}

// Select Selects all the rows from the table
func (table *Table) Select(rows int64) ([][]interface{}, *TableScheme) {
	table.manager.enqueueAPIUsage(1, true)
	return table.selectData(rows)
}

func BenchmarkSelect(t *testing.B) {
	// create table
	t.StopTimer()
	manager := NewSheetManager(jsonPath)
	db := manager.FindDatabase("testdb")
	if db == nil {
		t.Fatalf("Sheet %s is nil", "testdb")
	}

	// Find or make table
	table := db.FindTable(TestStructMeme{})
	if table == nil {
		table = db.createTable(TestStructMeme{})
	} 
	deleted := table.Drop()

	table = db.createTable(TestStructMeme{})
	
	values, _ := createRandomDataMeme()
	table.UpsertIf(values, true)
	for i := 0; i < 10; i++ {
		table.manager.enqueueAPIUsage(1, true)
		t.StartTimer()
		table.selectData(-1)
		t.StopTimer()
	}
	now := time.Now().In(time.FixedZone("GMT-7", -7*60*60)).Unix()
	next := ((now / 100) + 1) * 100
	<-time.NewTimer(time.Duration(next-now+1) * time.Second).C
}