/*
 * Copyright 1998-1999 Be, Inc. All Rights Reserved.
 * Copyright 2003-2019 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef CODYCAM_H
#define CODYCAM_H


#include <string.h>

#include <Application.h>
#include <Box.h>
#include <Catalog.h>
#include <CheckBox.h>
#include <Locale.h>
#include <Menu.h>
#include <MenuField.h>
#include <StringView.h>
#include <TextControl.h>
#include <Window.h>

#include "Settings.h"
#include "VideoConsumer.h"


class BMediaRoster;


enum {
        msg_filename    = 'file',

        msg_rate_changed = 'rate',

        msg_translate   = 'tran',

        msg_upl_client  = 'ucli',
        msg_server              = 'srvr',
        msg_login               = 'lgin',
        msg_password    = 'pswd',
        msg_directory   = 'drct',
        msg_passiveftp  = 'pasv',
        msg_pswrd_text  = 'pstx',

        msg_start               = 'strt',
        msg_stop                = 'stop',

        msg_setup               = 'setp',
        msg_video               = 'vdeo',

        msg_control_win = 'ctlw'
};


struct capture_rate {
        const char* name;
        time_t          seconds;
};


// NOTE: These are translated once the app catalog is loaded.
capture_rate kCaptureRates[] = {
        {"Every 15 seconds", 15 },
        {"Every 30 seconds", 30 },
        {"Every minute", 60 },
        {"Every 5 minutes", 5 * 60 },
        {"Every 10 minutes", 10 * 60 },
        {"Every 15 minutes", 15 * 60 },
        {"Every 30 minutes", 30 * 60 },
        {"Every hour", 60 * 60 },
        {"Every 2 hours", 2 * 60 * 60 },
        {"Every 4 hours", 4 * 60 * 60 },
        {"Every 8 hours", 8 * 60 * 60 },
        {"Every 24 hours", 24 * 60 * 60 },
        {"Never", 0 }
};


const int32 kCaptureRatesCount = sizeof(kCaptureRates) / sizeof(capture_rate);


const char* kUploadClients[] = {
        // NOTE: These are translated once the app catalog is loaded.
        "FTP",
        "SFTP",
        "Local"
};


const int32 kUploadClientsCount = sizeof(kUploadClients) / sizeof(char*);

class VideoWindow;
class ControlWindow;

class CodyCam : public BApplication {
public:
                                                        CodyCam();
        virtual                                 ~CodyCam();

                        void                    ReadyToRun();
        virtual bool                    QuitRequested();
        virtual void                    MessageReceived(BMessage* message);

private:
                        status_t                _SetUpNodes();
                        void                    _TearDownNodes();

                        BMediaRoster*   fMediaRoster;
                        media_node              fTimeSourceNode;
                        media_node              fProducerNode;
                        VideoConsumer*  fVideoConsumer;
                        media_output    fProducerOut;
                        media_input             fConsumerIn;
                        VideoWindow*    fWindow;
                        port_id                 fPort;
                        ControlWindow*  fVideoControlWindow;
};


class VideoWindow : public BWindow {
public:
                                                        VideoWindow(const char* title,
                                                                window_type type, uint32 flags,
                                                                port_id* consumerport);
                                                        ~VideoWindow();

        virtual bool                    QuitRequested();
        virtual void                    MessageReceived(BMessage* message);

                        void                    ApplyControls();

                        BView*                  VideoView();
                        BStringView*    StatusLine();
                        void                    ToggleMenuOnOff();

                        void                    ErrorAlert(const char*, status_t);

private:
                        void                    _BuildCaptureControls();

                        void                    _SetUpSettings(const char* filename,
                                                                const char* dirname);
                        void                    _UploadClientChanged();
                        void                    _QuitSettings();

private:
                        media_node*             fProducer;
                        port_id*                fPortPtr;

                        BView*                  fVideoView;
                        BTextView*              fErrorView;

                        BTextControl*   fFileName;
                        BBox*                   fCaptureSetupBox;
                        BMenu*                  fCaptureRateMenu;
                        BMenuField*             fCaptureRateSelector;
                        BMenu*                  fImageFormatMenu;
                        BMenuField*             fImageFormatSelector;
                        BMenu*                  fUploadClientMenu;
                        BMenuField*             fUploadClientSelector;
                        BBox*                   fFtpSetupBox;
                        BTextControl*   fServerName;
                        BTextControl*   fLoginId;
                        BTextControl*   fPassword;
                        BTextControl*   fDirectory;
                        BCheckBox*              fPassiveFtp;
                        BBox*                   fStatusBox;
                        BStringView*    fStatusLine;

                        ftp_msg_info    fFtpInfo;

                        Settings*               fSettings;

                        BMenu*                  fMenu;

                        StringValueSetting*             fServerSetting;
                        StringValueSetting*             fLoginSetting;
                        StringValueSetting*             fPasswordSetting;
                        StringValueSetting*             fDirectorySetting;
                        BooleanValueSetting*    fPassiveFtpSetting;
                        StringValueSetting*             fFilenameSetting;
                        StringValueSetting*             fImageFormatSettings;

                        EnumeratedStringValueSetting*   fUploadClientSetting;
                        EnumeratedStringValueSetting*   fCaptureRateSetting;
};


class ControlWindow : public BWindow {
public:
                                                        ControlWindow(BView* controls,
                                                                media_node node);
                        void                    MessageReceived(BMessage* message);
                        bool                    QuitRequested();

private:
                        BView*                  fView;
                        media_node              fNode;
};

#endif  // CODYCAM_H