package rifs

import (
	"fmt"
	"io"

	log "github.com/dsoprea/go-logging"
)

// BouncebackStats describes operation counts.
type BouncebackStats struct {
	reads  int
	writes int
	seeks  int
	syncs  int
}

func (bbs BouncebackStats) String() string {
	return fmt.Sprintf(
		"BouncebackStats<READS=(%d) WRITES=(%d) SEEKS=(%d) SYNCS=(%d)>",
		bbs.reads, bbs.writes, bbs.seeks, bbs.syncs)
}

type bouncebackBase struct {
	currentPosition int64

	stats BouncebackStats
}

// Position returns the position that we're supposed to be at.
func (bb *bouncebackBase) Position() int64 {

	// TODO(dustin): Add test

	return bb.currentPosition
}

// StatsReads returns the number of reads that have been attempted.
func (bb *bouncebackBase) StatsReads() int {

	// TODO(dustin): Add test

	return bb.stats.reads
}

// StatsWrites returns the number of write operations.
func (bb *bouncebackBase) StatsWrites() int {

	// TODO(dustin): Add test

	return bb.stats.writes
}

// StatsSeeks returns the number of seeks.
func (bb *bouncebackBase) StatsSeeks() int {

	// TODO(dustin): Add test

	return bb.stats.seeks
}

// StatsSyncs returns the number of corrective seeks ("bounce-backs").
func (bb *bouncebackBase) StatsSyncs() int {

	// TODO(dustin): Add test

	return bb.stats.syncs
}

// Seek does a seek to an arbitrary place in the `io.ReadSeeker`.
func (bb *bouncebackBase) seek(s io.Seeker, offset int64, whence int) (newPosition int64, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	// If the seek is relative, make sure we're where we're supposed to be *first*.
	if whence != io.SeekStart {
		err = bb.checkPosition(s)
		log.PanicIf(err)
	}

	bb.stats.seeks++

	newPosition, err = s.Seek(offset, whence)
	log.PanicIf(err)

	// Update our internal tracking.
	bb.currentPosition = newPosition

	return newPosition, nil
}

func (bb *bouncebackBase) checkPosition(s io.Seeker) (err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	// Make sure we're where we're supposed to be.

	// This should have no overhead, and enables us to collect stats.
	realCurrentPosition, err := s.Seek(0, io.SeekCurrent)
	log.PanicIf(err)

	if realCurrentPosition != bb.currentPosition {
		bb.stats.syncs++

		_, err = s.Seek(bb.currentPosition, io.SeekStart)
		log.PanicIf(err)
	}

	return nil
}

// BouncebackReader wraps a ReadSeeker, keeps track of our position, and
// seeks back to it before writing. This allows an underlying ReadWriteSeeker
// with an unstable position can still be used for a prolonged series of writes.
type BouncebackReader struct {
	rs io.ReadSeeker

	bouncebackBase
}

// NewBouncebackReader returns a `*BouncebackReader` struct.
func NewBouncebackReader(rs io.ReadSeeker) (br *BouncebackReader, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	initialPosition, err := rs.Seek(0, io.SeekCurrent)
	log.PanicIf(err)

	bb := bouncebackBase{
		currentPosition: initialPosition,
	}

	br = &BouncebackReader{
		rs:             rs,
		bouncebackBase: bb,
	}

	return br, nil
}

// Seek does a seek to an arbitrary place in the `io.ReadSeeker`.
func (br *BouncebackReader) Seek(offset int64, whence int) (newPosition int64, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	newPosition, err = br.bouncebackBase.seek(br.rs, offset, whence)
	log.PanicIf(err)

	return newPosition, nil
}

// Seek does a standard read.
func (br *BouncebackReader) Read(p []byte) (n int, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	br.bouncebackBase.stats.reads++

	err = br.bouncebackBase.checkPosition(br.rs)
	log.PanicIf(err)

	// Do read.

	n, err = br.rs.Read(p)
	if err != nil {
		if err == io.EOF {
			return 0, io.EOF
		}

		log.Panic(err)
	}

	// Update our internal tracking.
	br.bouncebackBase.currentPosition += int64(n)

	return n, nil
}

// BouncebackWriter wraps a WriteSeeker, keeps track of our position, and
// seeks back to it before writing. This allows an underlying ReadWriteSeeker
// with an unstable position can still be used for a prolonged series of writes.
type BouncebackWriter struct {
	ws io.WriteSeeker

	bouncebackBase
}

// NewBouncebackWriter returns a new `BouncebackWriter` struct.
func NewBouncebackWriter(ws io.WriteSeeker) (bw *BouncebackWriter, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	initialPosition, err := ws.Seek(0, io.SeekCurrent)
	log.PanicIf(err)

	bb := bouncebackBase{
		currentPosition: initialPosition,
	}

	bw = &BouncebackWriter{
		ws:             ws,
		bouncebackBase: bb,
	}

	return bw, nil
}

// Seek puts us at a specific position in the internal writer for the next
// write/seek.
func (bw *BouncebackWriter) Seek(offset int64, whence int) (newPosition int64, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	newPosition, err = bw.bouncebackBase.seek(bw.ws, offset, whence)
	log.PanicIf(err)

	return newPosition, nil
}

// Write performs a write against the internal `WriteSeeker` starting at the
// position that we're supposed to be at.
func (bw *BouncebackWriter) Write(p []byte) (n int, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	bw.bouncebackBase.stats.writes++

	// Make sure we're where we're supposed to be.

	realCurrentPosition, err := bw.ws.Seek(0, io.SeekCurrent)
	log.PanicIf(err)

	if realCurrentPosition != bw.bouncebackBase.currentPosition {
		bw.bouncebackBase.stats.seeks++

		_, err = bw.ws.Seek(bw.bouncebackBase.currentPosition, io.SeekStart)
		log.PanicIf(err)
	}

	// Do write.

	n, err = bw.ws.Write(p)
	log.PanicIf(err)

	// Update our internal tracking.
	bw.bouncebackBase.currentPosition += int64(n)

	return n, nil
}