// parseSelectedTags parses url for selected tags and redirects if it refers to missing tags
func parseSelectedTags(w http.ResponseWriter, r *http.Request, notebook *tessernote.Notebook, c appengine.Context) ([]tessernote.Tag, error) {
	var names []string
	if r.URL.Path != "/" && r.URL.Path != untaggedURL {
		names = strings.Split(r.URL.Path[1:], tagSeparator)
	}
	tags, err := notebook.TagsFrom(names, c)
	if err != nil {
		names = tessernote.Name(tags)
		tagString := strings.Join(names, tagSeparator)
		http.Redirect(w, r, "/"+tagString, http.StatusFound)
	}
	return tags, err
}

// GetAllNotes writes a JSON formatted list of all Note IDs in the authorized User's Notebook to w.
func GetAllNotes(w http.ResponseWriter, c appengine.Context, notebook *tessernote.Notebook) {
	notes, err := notebook.Notes(c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	reply, err := json.Marshal(notes)
	if err != nil {
		c.Errorf("marshaling notes (%d): %s", len(notes), err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(reply)
}

func TestCreateNote(t *testing.T) {
	note := tessernote.Note{Body: "body"}
	bytes, err := json.Marshal(note)
	if err != nil {
		t.Fatal(err)
	}
	w := httptest.NewRecorder()
	r, err := http.NewRequest("POST", "https://tessernote.appspot.com"+NotesURL, strings.NewReader(string(bytes)))
	if err != nil {
		t.Fatal(err)
	}

	// create a test notebook
	notebook := new(tessernote.Notebook)
	c, err := appenginetesting.NewContext(nil)
	defer c.Close()
	if err != nil {
		t.Fatal(err)
	}
	key := datastore.NewIncompleteKey(c, "Notebook", nil)
	key, err = datastore.Put(c, key, notebook)
	if err != nil {
		t.Fatal(err)
	}
	notebook.ID = key.Encode()

	CreateNote(w, r, c, notebook)

	// check note was added
	notes, err := notebook.Notes(c)
	if err != nil {
		t.Fatal(err)
	}
	if len(notes) != 1 {
		t.Fatalf("expected=%d actual=%d", 1, len(notes))
	}
	if notes[0].Body != note.Body {
		t.Fatalf("expected=%s actual=%s", notes[0].Body, note.Body)
	}

	// check response ID is the same
	response := []byte(w.Body.String())
	err = json.Unmarshal(response, note)
	if err != nil {
		t.Fatal(err, string(response))
	}
	if notes[0].ID != note.ID {
		t.Fatalf("expected=%s actual=%s", notes[0].ID, note.ID)
	}
}

// DeleteNote deletes a Note by the ID in the URL. Uses w to write true if the Note was deleted, false
// if it never existed.
func DeleteNote(w http.ResponseWriter, r *http.Request, c appengine.Context, notebook *tessernote.Notebook) {
	id := r.URL.Path[len(NotesURL):]
	deleted, err := notebook.Delete(id, c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	reply, err := json.Marshal(deleted)
	if err != nil {
		c.Errorf("marshaling delete response (%t): %s", deleted, err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(reply)
}

// GetNote retrieves a note from the authorized User's Notebook by ID. The Note is written in JSON format to w.
func GetNote(w http.ResponseWriter, r *http.Request, c appengine.Context, notebook *tessernote.Notebook) {
	id := r.URL.Path[len(NotesURL):]
	note, err := notebook.Note(id, c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	reply, err := json.Marshal(note)
	if err != nil {
		c.Errorf("marshaling note (%#v): %s", note, err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(reply)
}

// DeleteAllNotes deletes all Notes from the authorized User's Notebook. It writes true if Notes were deleted,
// and false if the Notebook was empty to w.
func DeleteAllNotes(w http.ResponseWriter, c appengine.Context, notebook *tessernote.Notebook) {
	empty := len(notebook.NoteKeys) == 0
	err := notebook.DeleteAll(c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	reply, err := json.Marshal(!empty)
	if err != nil {
		c.Errorf("marshaling delete all response: %s", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(reply)
}

// CreateNote creates a new Note in the authorized User's Notebook. It takes as input a JSON formatted Note
// and writes the new Note (with its automatically assigned unique ID) in JSON format to w.
func CreateNote(w http.ResponseWriter, r *http.Request, c appengine.Context, notebook *tessernote.Notebook) {
	note, err := readNote(w, r)
	if err != nil {
		return
	}
	note, err = notebook.Put(note, c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	reply, err := json.Marshal(note)
	if err != nil {
		c.Errorf("marshaling note (%#v): %s", note, err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(reply)
}

// ReplaceAllNotes replaces the Notes of the authorized User's Notebook with a new set of Notes. It takes as
// input a JSON formatted list of Notes and writes the added notes if succeeded or an error message otherwise to w.
// Notes may be written back with different IDs than those submitted, see ReplaceNote().
func ReplaceAllNotes(w http.ResponseWriter, r *http.Request, c appengine.Context, notebook *tessernote.Notebook) {
	notes, err := readNotes(w, r)
	if err != nil {
		return
	}
	err = notebook.DeleteAll(c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	notes, err = notebook.PutAll(notes, c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	reply, err := json.Marshal(notes)
	if err != nil {
		c.Errorf("marshaling notes (%d): %s", len(notes), err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(reply)
}

// ReplaceNote replaces a Note in the authorized User's Notebook by its ID. If the Note doesn't exist it is created.
// If the Note's ID has already been assigned (e.g. in another Notebook) a new one is generated for this Note.
// The Note is written in JSON format to w.
func ReplaceNote(w http.ResponseWriter, r *http.Request, c appengine.Context, notebook *tessernote.Notebook) {
	id := r.URL.Path[len(NotesURL):]
	note, err := readNote(w, r)
	if err != nil {
		return
	}
	if id != note.ID {
		http.Error(w, "mismatched note.ID and URL", http.StatusBadRequest)
		return
	}
	note, err = notebook.Put(note, c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	reply, err := json.Marshal(note)
	if err != nil {
		c.Errorf("marshaling note (%#v): %s", note, err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(reply)
}