/*****************************************************************************/
// SlideShowSaver
// Written by Michael Wilber
// Slide show code derived from ShowImage code, written by Michael Pfeiffer
//
// SlideShowSaver.cpp
//
//
// Copyright (C) Haiku
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/


#include "SlideShowSaver.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <BitmapStream.h>
#include <Catalog.h>
#include <Directory.h>
#include <File.h>
#include <List.h>
#include <Path.h>
#include <StringView.h>
#include <TranslatorRoster.h>

#include "SlideShowConfigView.h"


// Called by system to get the screen saver
extern "C" _EXPORT BScreenSaver *
instantiate_screen_saver(BMessage *message, image_id id)
{
        return new SlideShowSaver(message, id);
}

// returns B_ERROR if problems reading ref
// B_OK if ref is not a directory
// B_OK + 1 if ref is a directory
status_t
ent_is_dir(const entry_ref *ref)
{
        BEntry ent(ref);
        if (ent.InitCheck() != B_OK)
                return B_ERROR;

        struct stat st;
        if (ent.GetStat(&st) != B_OK)
                return B_ERROR;

        return S_ISDIR(st.st_mode) ? (B_OK + 1) : B_OK;
}

int CompareEntries(const void* a, const void* b)
{
        entry_ref *r1, *r2;
        r1 = *(entry_ref**)a;
        r2 = *(entry_ref**)b;
        return strcasecmp(r1->name, r2->name);
}

// Default settings for the Translator
LiveSetting gDefaultSettings[] = {
        LiveSetting(CHANGE_CAPTION, SAVER_SETTING_CAPTION, true),
                // Show image caption by default
        LiveSetting(CHANGE_BORDER, SAVER_SETTING_BORDER, true),
                // Show image border by default
        LiveSetting(CHANGE_DIRECTORY, SAVER_SETTING_DIRECTORY, "/boot/home"),
                // Set default image directory to home
        LiveSetting(CHANGE_DELAY, SAVER_SETTING_DELAY, (int32) 3000)
                // Default delay: 3 seconds
};

SlideShowSaver::SlideShowSaver(BMessage *archive, image_id image)
        :
        BScreenSaver(archive, image), fLock("SlideShow Lock")
{
        B_TRANSLATE_MARK_SYSTEM_NAME_VOID("SlideShowSaver");

        fNewDirectory = true;
        fBitmap = NULL;
        fShowBorder = true;
        fShowCaption = true;

        fSettings = new LiveSettings("SlideShowSaver_Settings",
                gDefaultSettings, sizeof(gDefaultSettings) / sizeof(LiveSetting));
        fSettings->LoadSettings();
                // load settings from the settings file

        fSettings->AddObserver(this);
}

SlideShowSaver::~SlideShowSaver()
{
        delete fBitmap;
        fBitmap = NULL;

        fSettings->RemoveObserver(this);
        fSettings->Release();
}

// Called by fSettings to notify that someone has changed
// a setting. For example, if the user changes a setting
// on the config panel, this will be called to notify this
// object.
void
SlideShowSaver::SettingChanged(uint32 setting)
{
        switch (setting) {
                case CHANGE_CAPTION:
                        UpdateShowCaption();
                        break;
                case CHANGE_BORDER:
                        UpdateShowBorder();
                        break;
                case CHANGE_DIRECTORY:
                        UpdateDirectory();
                        break;
                case CHANGE_DELAY:
                        UpdateTickSize();
                        break;

                default:
                        break;
        }
}

status_t
SlideShowSaver::UpdateTickSize()
{
        // Tick size is in microseconds, but is stored in settings as
        // milliseconds
        bigtime_t ticks = static_cast<bigtime_t>
                (fSettings->SetGetInt32(SAVER_SETTING_DELAY)) * 1000;
        SetTickSize(ticks);

        return B_OK;
}

status_t
SlideShowSaver::UpdateShowCaption()
{
        fShowCaption = fSettings->SetGetBool(SAVER_SETTING_CAPTION);
        return B_OK;
}

status_t
SlideShowSaver::UpdateShowBorder()
{
        fShowBorder = fSettings->SetGetBool(SAVER_SETTING_BORDER);
        return B_OK;
}

status_t
SlideShowSaver::UpdateDirectory()
{
        status_t result = B_OK;

        fLock.Lock();

        BString strDirectory;
        fSettings->GetString(SAVER_SETTING_DIRECTORY, strDirectory);
        BDirectory dir(strDirectory.String());
        if (dir.InitCheck() != B_OK || dir.GetNextRef(&fCurrentRef) != B_OK)
                result = B_ERROR;
        // Use ShowNextImage to find which translatable image is
        // alphabetically first in the given directory, and load it
        if (result == B_OK && ShowNextImage(true, true) == false)
                result = B_ERROR;

        fNewDirectory = true;

        fLock.Unlock();

        return result;
}

void
SlideShowSaver::StartConfig(BView *view)
{
        view->AddChild(new SlideShowConfigView(
                BRect(10, 10, 250, 300), "SlideShowSaver Config",
                B_FOLLOW_ALL, B_WILL_DRAW, fSettings->Acquire()));
}

status_t
SlideShowSaver::StartSaver(BView *view, bool preview)
{
        UpdateShowCaption();
        UpdateShowBorder();

        if (UpdateDirectory() != B_OK)
                return B_ERROR;

        // Read ticksize setting and set it as the delay
        UpdateTickSize();

        return B_OK;
}

void
SlideShowSaver::Draw(BView *view, int32 frame)
{
        fLock.Lock();

        view->SetLowColor(0, 0, 0);
        view->SetHighColor(192, 192, 192);
        view->SetViewColor(192, 192, 192);

        bool bResult = false;
        if (fNewDirectory == true) {
                // Already have a bitmap on the first frame
                bResult = true;
        } else {
                bResult = ShowNextImage(true, false);
                // try rewinding to beginning
                if (bResult == false)
                        bResult = ShowNextImage(true, true);
        }
        fNewDirectory = false;

        if (bResult == true && fBitmap != NULL) {
                BRect destRect(0, 0, fBitmap->Bounds().Width(), fBitmap->Bounds().Height()),
                        vwBounds = view->Bounds();

                if (destRect.Width() < vwBounds.Width()) {
                        destRect.OffsetBy((vwBounds.Width() - destRect.Width()) / 2, 0);
                }
                if (destRect.Height() < vwBounds.Height()) {
                        destRect.OffsetBy(0, (vwBounds.Height() - destRect.Height()) / 2);
                }

                BRect border = destRect, bounds = view->Bounds();
                // top
                view->FillRect(BRect(0, 0, bounds.right, border.top-1), B_SOLID_LOW);
                // left
                view->FillRect(BRect(0, border.top, border.left-1, border.bottom), B_SOLID_LOW);
                // right
                view->FillRect(BRect(border.right+1, border.top, bounds.right, border.bottom), B_SOLID_LOW);
                // bottom
                view->FillRect(BRect(0, border.bottom+1, bounds.right, bounds.bottom), B_SOLID_LOW);

                if (fShowBorder == true) {
                        BRect strokeRect = destRect;
                        strokeRect.InsetBy(-1, -1);
                        view->StrokeRect(strokeRect);
                }

                view->DrawBitmap(fBitmap, fBitmap->Bounds(), destRect);

                if (fShowCaption == true)
                        DrawCaption(view);
        }

        fLock.Unlock();
}

status_t
SlideShowSaver::SetImage(const entry_ref *pref)
{
        entry_ref ref;
        if (!pref)
                ref = fCurrentRef;
        else
                ref = *pref;

        BTranslatorRoster *proster = BTranslatorRoster::Default();
        if (!proster)
                return B_ERROR;

        if (ent_is_dir(pref) != B_OK)
                // if ref is erroneous or a directory, return error
                return B_ERROR;

        BFile file(&ref, B_READ_ONLY);
        translator_info info;
        memset(&info, 0, sizeof(translator_info));
        BMessage ioExtension;
        //if (ref != fCurrentRef)
                // if new image, reset to first document
        //      fDocumentIndex = 1;
        if (ioExtension.AddInt32("/documentIndex", 1 /*fDocumentIndex*/) != B_OK)
                return B_ERROR;
        if (proster->Identify(&file, &ioExtension, &info, 0, NULL,
                B_TRANSLATOR_BITMAP) != B_OK)
                return B_ERROR;

        // Translate image data and create a new ShowImage window
        BBitmapStream outstream;
        if (proster->Translate(&file, &info, &ioExtension, &outstream,
                B_TRANSLATOR_BITMAP) != B_OK)
                return B_ERROR;
        BBitmap *newBitmap = NULL;
        if (outstream.DetachBitmap(&newBitmap) != B_OK)
                return B_ERROR;

        // Now that I've successfully loaded the new bitmap,
        // I can be sure it is safe to delete the old one,
        // and clear everything
        delete fBitmap;
        fBitmap = newBitmap;
        newBitmap = NULL;
        fCurrentRef = ref;

        // Get path to use in caption
        fCaption = "<< Unable to read the path >>";
        BEntry entry(&fCurrentRef);
        if (entry.InitCheck() == B_OK) {
                BPath path(&entry);
                if (path.InitCheck() == B_OK) {
                        fCaption = path.Path();
                }
        }

        return B_OK;
}

// Function originally from Haiku ShowImage
bool
SlideShowSaver::ShowNextImage(bool next, bool rewind)
{
        bool found;
        entry_ref curRef, imgRef;

        curRef = fCurrentRef;
        found = FindNextImage(&curRef, &imgRef, next, rewind);
        if (found) {
                // Keep trying to load images until:
                // 1. The image loads successfully
                // 2. The last file in the directory is found (for find next or find first)
                // 3. The first file in the directory is found (for find prev)
                // 4. The call to FindNextImage fails for any other reason
                while (SetImage(&imgRef) != B_OK) {
                        curRef = imgRef;
                        found = FindNextImage(&curRef, &imgRef, next, false);
                        if (!found)
                                return false;
                }
                return true;
        }
        return false;
}

// Function taken from Haiku ShowImage,
// function originally written by Michael Pfeiffer
bool
SlideShowSaver::IsImage(const entry_ref *pref)
{
        if (!pref)
                return false;

        if (ent_is_dir(pref) != B_OK)
                // if ref is erroneous or a directory, return false
                return false;

        BFile file(pref, B_READ_ONLY);
        if (file.InitCheck() != B_OK)
                return false;

        BTranslatorRoster *proster = BTranslatorRoster::Default();
        if (!proster)
                return false;

        BMessage ioExtension;
        if (ioExtension.AddInt32("/documentIndex", 1) != B_OK)
                return false;

        translator_info info;
        memset(&info, 0, sizeof(translator_info));
        if (proster->Identify(&file, &ioExtension, &info, 0, NULL,
                B_TRANSLATOR_BITMAP) != B_OK)
                return false;

        return true;
}

// Function taken from Haiku ShowImage,
// function originally written by Michael Pfeiffer
bool
SlideShowSaver::FindNextImage(entry_ref *in_current, entry_ref *out_image, bool next, bool rewind)
{
//      ASSERT(next || !rewind);
        BEntry curImage(in_current);
        entry_ref entry, *ref;
        BDirectory parent;
        BList entries;
        bool found = false;
        int32 cur;

        if (curImage.GetParent(&parent) != B_OK)
                return false;

        while (parent.GetNextRef(&entry) == B_OK) {
                if (entry != *in_current) {
                        entries.AddItem(new entry_ref(entry));
                } else {
                        // insert current ref, so we can find it easily after sorting
                        entries.AddItem(in_current);
                }
        }

        entries.SortItems(CompareEntries);

        cur = entries.IndexOf(in_current);
//      ASSERT(cur >= 0);

        // remove it so FreeEntries() does not delete it
        entries.RemoveItem(in_current);

        if (next) {
                // find the next image in the list
                if (rewind) cur = 0; // start with first
                for (; (ref = (entry_ref*)entries.ItemAt(cur)) != NULL; cur ++) {
                        if (IsImage(ref)) {
                                found = true;
                                *out_image = (const entry_ref)*ref;
                                break;
                        }
                }
        } else {
                // find the previous image in the list
                cur --;
                for (; cur >= 0; cur --) {
                        ref = (entry_ref*)entries.ItemAt(cur);
                        if (IsImage(ref)) {
                                found = true;
                                *out_image = (const entry_ref)*ref;
                                break;
                        }
                }
        }

        FreeEntries(&entries);
        return found;
}

// Function taken from Haiku ShowImage,
// function originally written by Michael Pfeiffer
void
SlideShowSaver::FreeEntries(BList *entries)
{
        const int32 n = entries->CountItems();
        for (int32 i = 0; i < n; i ++) {
                entry_ref *ref = (entry_ref *)entries->ItemAt(i);
                delete ref;
        }
        entries->MakeEmpty();
}

void
SlideShowSaver::LayoutCaption(BView *view, BFont &font, BPoint &pos, BRect &rect)
{
        font_height fontHeight;
        float width, height;
        BRect bounds(view->Bounds());
        font = be_plain_font;
        width = font.StringWidth(fCaption.String()) + 1; // 1 for text shadow
        font.GetHeight(&fontHeight);
        height = fontHeight.ascent + fontHeight.descent;
        // center text horizontally
        pos.x = (bounds.left + bounds.right - width)/2;
        // flush bottom
        pos.y = bounds.bottom - fontHeight.descent - 5;

        // background rectangle
        rect.Set(0, 0, (width-1)+2, (height-1)+2+1); // 2 for border and 1 for text shadow
        rect.OffsetTo(pos);
        rect.OffsetBy(-1, -1-fontHeight.ascent); // -1 for border
}

void
SlideShowSaver::DrawCaption(BView *view)
{
        BFont font;
        BPoint pos;
        BRect rect;
        LayoutCaption(view, font, pos, rect);

        view->PushState();
        // draw background
        view->SetDrawingMode(B_OP_ALPHA);
        view->SetHighColor(0, 0, 255, 128);
        view->FillRect(rect);
        // draw text
        view->SetDrawingMode(B_OP_OVER);
        view->SetFont(&font);
        view->SetLowColor(B_TRANSPARENT_COLOR);
        // text shadow
        pos += BPoint(1, 1);
        view->SetHighColor(0, 0, 0);
        view->SetPenSize(1);
        view->DrawString(fCaption.String(), pos);
        // text
        pos -= BPoint(1, 1);
        view->SetHighColor(255, 255, 0);
        view->DrawString(fCaption.String(), pos);
        view->PopState();
}