package mdb

/*
func (db *Database) openSecondary() (err error) {
	if db.shouldLoadFromPrimary() {
		if err := db.loadFromPrimary(); err != nil {
			return err
		}
	}

	log.Printf("Opening page-file...")

	pFile, err := openPageFileAndReplayWAL(db.rootDir)
	if err != nil {
		return err
	}
	defer pFile.Close()

	pfHeader, err := pFile.ReadHeader()
	if err != nil {
		return err
	}

	log.Printf("Building page-file index...")

	pIndex, err := pagefile.NewIndex(pFile)
	if err != nil {
		return err
	}

	tx := db.Snapshot()
	tx.seqNum = pfHeader.SeqNum
	tx.updatedAt = pfHeader.UpdatedAt

	log.Printf("Loading data into memory...")

	err = pFile.IterateAllocated(pIndex, func(cID, iID uint64, data []byte) error {
		return db.loadItem(tx, cID, iID, data)
	})
	if err != nil {
		return err
	}

	log.Printf("Creating writer...")

	w, err := cswal.OpenWriter(db.walRootDir, &cswal.WriterConfig{
		SegMinCount:  db.conf.WALSegMinCount,
		SegMaxAgeSec: db.conf.WALSegMaxAgeSec,
	})
	if err != nil {
		return err
	}

	db.done.Add(1)
	go (&walFollower{
		Stop:   db.stop,
		Done:   db.done,
		W:      w,
		Client: NewClient(db.conf.PrimaryURL, db.conf.ReplicationPSK, db.conf.NetTimeout),
	}).Run()

	db.done.Add(1)
	go (&follower{
		Stop:         db.stop,
		Done:         db.done,
		WALRootDir:   db.walRootDir,
		SeqNum:       pfHeader.SeqNum,
		ApplyChanges: db.applyChanges,
	}).Run()

	db.done.Add(1)
	go (&fileWriter{
		Stop:         db.stop,
		Done:         db.done,
		PageFilePath: db.pageFilePath,
		WALRootDir:   db.walRootDir,
	}).Run()

	return nil
}

func (db *Database) shouldLoadFromPrimary() bool {
	if _, err := os.Stat(db.walRootDir); os.IsNotExist(err) {
		log.Printf("WAL doesn't exist.")
		return true
	}
	if _, err := os.Stat(db.pageFilePath); os.IsNotExist(err) {
		log.Printf("Page-file doesn't exist.")
		return true
	}
	return false
}

func (db *Database) loadFromPrimary() error {
	client := NewClient(db.conf.PrimaryURL, db.conf.ReplicationPSK, db.conf.NetTimeout)
	defer client.Disconnect()

	log.Printf("Loading data from primary...")

	if err := os.RemoveAll(db.pageFilePath); err != nil {
		log.Printf("Failed to remove page-file: %s", err)
		return errs.IO.WithErr(err) // Caller can retry.
	}

	if err := os.RemoveAll(db.walRootDir); err != nil {
		log.Printf("Failed to remove WAL: %s", err)
		return errs.IO.WithErr(err) // Caller can retry.
	}

	err := client.DownloadPageFile(db.pageFilePath+".tmp", db.pageFilePath)
	if err != nil {
		log.Printf("Failed to get page-file from primary: %s", err)
		return err // Caller can retry.
	}

	pfHeader, err := pagefile.ReadHeader(db.pageFilePath)
	if err != nil {
		log.Printf("Failed to read page-file sequence number: %s", err)
		return err // Caller can retry.
	}

	if err = cswal.CreateEx(db.walRootDir, pfHeader.SeqNum+1); err != nil {
		log.Printf("Failed to initialize WAL: %s", err)
		return err // Caller can retry.
	}

	return nil
}
*/