/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "lpsched.h"
#include <syslog.h>

static int      max_requests_needing_form_mounted ( FSTATUS * );
static int      max_requests_needing_pwheel_mounted ( char * );

/**
 ** queue_form() - ADD A REQUEST TO A FORM QUEUE
 **/

void
queue_form(RSTATUS *prs, FSTATUS *pfs)
{
        if ((prs->form = pfs) != NULL) {
                prs->form->requests++;
                if (prs->printer)
                        check_form_alert (prs->form, (_FORM *)0);
        }
        return;
}

/**
 ** unqueue_form() - REMOVE A REQUEST FROM A FORM QUEUE
 **/

void
unqueue_form(RSTATUS *prs)
{
        FSTATUS *               pfs     = prs->form;

        prs->form = 0;
        if (pfs) {
                pfs->requests--;
                if (prs->printer)
                        check_form_alert (pfs, (_FORM *)0);
        }
        return;
}

/**
 ** queue_pwheel() - ADD A REQUEST TO A PRINT WHEEL QUEUE
 **/

void
queue_pwheel(RSTATUS *prs, char *name)
{
        if (name) {
                prs->pwheel_name = Strdup(name);
                /*
                 * Don't bother queueing the request for
                 * a print wheel if this request is destined for
                 * only this printer and the printer doesn't take
                 * print wheels.
                 */
                if (
                        !one_printer_with_charsets(prs)
                     && (prs->pwheel = search_pwstatus(name))
                ) {
                        prs->pwheel->requests++;
                        check_pwheel_alert (prs->pwheel, (PWHEEL *)0);
                }
        }
        return;
}

/**
 ** unqueue_pwheel() - REMOVE A REQUEST FROM A PRINT WHEEL QUEUE
 **/

void
unqueue_pwheel(RSTATUS *prs)
{
        PWSTATUS *              ppws    = prs->pwheel;

        prs->pwheel = 0;
        unload_str (&(prs->pwheel_name));
        if (ppws) {
                ppws->requests--;
                check_pwheel_alert (ppws, (PWHEEL *)0);
        }
        return;
}

/**
 ** check_form_alert() - CHECK CHANGES TO MOUNT FORM ALERT
 **/

void
check_form_alert(FSTATUS *pfs, _FORM *pf)
{
        short                   trigger,
                                fire_off_alert  = 0;

        int                     requests_waiting;


        /*
         * Call this routine whenever a requests has been queued
         * or dequeued for a form, and whenever the form changes.
         * If a pointer to a new _FORM is passed, the FSTATUS
         * structure is updated with the changes. Use a second
         * argument of 0 if no change.
         *
         * WARNING: It is valid to call this routine when adding
         * a NEW form (not just changing it). Thus the members of
         * the structure "pfs->form" may not be set.
         * In this case, though, "pf" MUST be set, and there can
         * be NO alert active.
         */

        syslog(LOG_DEBUG, "check_form_alert:\n");
        if (pfs)
                syslog(LOG_DEBUG, "check_form_alert: pfs->name <%s>\n",
                        (pfs->form->name != NULL) ? pfs->form->name : "null");
        if (pf)
                syslog(LOG_DEBUG, "check_form_alert: pf->name <%s>\n",
                        (pf->name != NULL) ? pf->name : "null");


        if (pf) {
                if ((trigger = pf->alert.Q) <= 0)
                        trigger = 1;
        } else
                trigger = pfs->trigger;

        if (Starting)
                goto Return;

#define OALERT  pfs->form->alert
#define NALERT  pf->alert

        requests_waiting = max_requests_needing_form_mounted(pfs);

        /*
         * Cancel an active alert if the number of requests queued
         * has dropped below the threshold (or the threshold has been
         * raised), or if the alert command or period has changed.
         * In the latter case we'll reactive the alert later.
         */
        if (pfs->alert->active)
                if (!requests_waiting || requests_waiting < trigger)
                        cancel_alert (A_FORM, pfs);

                else if (
                        pf
                     && (
                                !SAME(NALERT.shcmd, OALERT.shcmd)
                             || NALERT.W != OALERT.W
                             || NALERT.Q != OALERT.Q
                        )
                )
                        cancel_alert (A_FORM, pfs);

        /*
         * If we still have the condition for an alert, we'll fire
         * one off. It is possible the alert is still running, but
         * that's okay. First, we may want to change the alert message;
         * second, the "alert()" routine doesn't execute an alert
         * if it is already running.
         */
        if (trigger > 0 && requests_waiting >= trigger)
                if ((pf && NALERT.shcmd) || OALERT.shcmd)
                        fire_off_alert = 1;

#undef  OALERT
#undef  NALERT

Return: if (pf) {

                 pfs->form = pf;

                pfs->trigger = trigger;
        }

        /*
         * Have to do this after updating the changes.
         */
        if (fire_off_alert)
                alert (A_FORM, pfs);

        return;
}

/**
 ** check_pwheel_alert() - CHECK CHANGES TO MOUNT PRINTWHEEL ALERT
 **/

void
check_pwheel_alert(PWSTATUS *ppws, PWHEEL *ppw)
{
        short                   trigger,
                                fire_off_alert  = 0;
        int                     requests_waiting;


        /*
         * Call this routine whenever a request has been queued
         * or dequeued for a print-wheel, and whenever the print-wheel
         * changes. If a pointer to a new PWHEEL is passed, the
         * PWSTATUS structure is updated with the changes. Use a
         * second argument of 0 if no change.
         *
         * WARNING: It is valid to call this routine when adding
         * a NEW print wheel (not just changing it). Thus the members
         * of the structure "ppws->pwheel" may not be set.
         * In this case, though, "ppw" MUST be set, and there can
         * be NO alert active.
         */

        if (ppw) {
                if ((trigger = ppw->alert.Q) <= 0)
                        trigger = 1;
        } else
                trigger = ppws->trigger;

        if (Starting)
                goto Return;

#define OALERT  ppws->pwheel->alert
#define NALERT  ppw->alert

        requests_waiting = max_requests_needing_pwheel_mounted(ppws->pwheel->name);

        /*
         * Cancel an active alert if the number of requests queued
         * has dropped below the threshold (or the threshold has been
         * raised), or if the alert command or period has changed.
         * In the latter case we'll reactive the alert later.
         */
        if (ppws->alert->active)
                if (!requests_waiting || requests_waiting < trigger)
                        cancel_alert (A_PWHEEL, ppws);

                else if (
                        ppw
                     && (
                                !SAME(NALERT.shcmd, OALERT.shcmd)
                             || NALERT.W != OALERT.W
                             || NALERT.Q != OALERT.Q
                        )
                )
                        cancel_alert (A_PWHEEL, ppws);

        /*
         * If we still have the condition for an alert, we'll fire
         * one off. It is possible the alert is still running, but
         * that's okay. First, we may want to change the alert message;
         * second, the "alert()" routine doesn't execute an alert
         * if it is already running.
         */
        if (trigger > 0 && requests_waiting >= trigger)
                if ((ppw && NALERT.shcmd) || OALERT.shcmd)
                        fire_off_alert = 1;

#undef  OALERT
#undef  NALERT

Return: if (ppw) {

                ppws->pwheel = ppw;
                ppws->trigger = trigger;
        }

        /*
         * Have to do this after updating the changes.
         */
        if (fire_off_alert)
                alert (A_PWHEEL, ppws);

        return;
}

static int
trayWithForm(PSTATUS *pps, FSTATUS *pfs, int startingTray, int checkAvail)
{
        int i;
        PFSTATUS *ppfs;

        ppfs = pps->forms;
        if (startingTray < 0)
                startingTray = 0;

        if (ppfs) {
                for (i = startingTray; i < pps->numForms; i++)
                        if ((!checkAvail || ppfs[i].isAvailable) &&
                            (ppfs[i].form == pfs))
                                        return(i);
        }
        else if (!pfs)
                /* no form request matches no form mounted */
                return(0);

        return(-1);
}

char *
allTraysWithForm(PSTATUS *pps, FSTATUS *pfs)
{

        int tray = 0;
        char *ptr, *p;
        char trayList[MAX_INPUT];
        int n;

        ptr = trayList;
        if (pfs && pfs->form && pfs->form->paper)
                p = pfs->form->paper;
        else
                p = "";

        n = sizeof (trayList);
        snprintf(ptr, n, "LP_TRAY_ARG=%s:", p);

        ptr += strlen(ptr);
        n -= strlen(ptr);

        while ((tray = trayWithForm(pps, pfs, tray, 1)) > 0) {
                tray++;
                snprintf(ptr, n, "%d,", tray);
                ptr += strlen(ptr);
                n -= strlen(ptr);
        }
        if (*(ptr-1) == ',')
                *(ptr-1) = 0;

        putenv(trayList);
        return(NULL);
}

int
isFormUsableOnPrinter(PSTATUS *pps, FSTATUS *pfs)
{
        return (trayWithForm(pps,pfs,0,1) >= 0 );
}
int
isFormMountedOnPrinter(PSTATUS *pps, FSTATUS *pfs)
{
        return (trayWithForm(pps,pfs,0,0) >= 0 );
}

/**
 ** max_requests_needing_form_mounted()
 ** max_requests_needing_pwheel_mounted()
 **/

static int
max_requests_needing_form_mounted(FSTATUS *pfs)
{
        PSTATUS *               pps;
        RSTATUS *               prs;
        int                     max     = 0;
        int                     i;

        /*
         * For each printer that doesn't have this form mounted,
         * count the number of requests needing this form and
         * assigned to the printer. Find the maximum across all such
         * printers. Sorry, the code actually has a different loop
         * (it steps through the requests) but the description of what
         * happens below is easier to understand as given. (Looping
         * through the printers would result in #printers x #requests
         * steps, whereas this entails #requests steps.)
         */
        for (i = 0; PStatus != NULL && PStatus[i] != NULL; i++)
                PStatus[i]->nrequests = 0;

        for (prs = Request_List; prs != NULL; prs = prs->next)
                if ((prs->form == pfs) && ((pps = prs->printer) != NULL) &&
                    (!isFormMountedOnPrinter(pps,pfs)) &&
                    (++pps->nrequests >= max))
                        max = pps->nrequests;

        if (NewRequest)
                if (((pps = NewRequest->printer) != NULL) &&
                    (!isFormMountedOnPrinter(pps,pfs)))
                        if (++pps->nrequests >= max)
                                max = pps->nrequests;
        return (max);
}

static int
max_requests_needing_pwheel_mounted(char *pwheel_name)
{
        PSTATUS *               pps;
        RSTATUS *               prs;
        int                     max     = 0;
        int                     i;


        /*
         * For each printer that doesn't have this print-wheel mounted,
         * count the number of requests needing this print-wheel and
         * assigned to the printer. Find the maximum across all such
         * printers. Sorry, the code actually has a different loop
         * (it steps through the requests) but the description of what
         * happens below is easier to understand as given. (Looping
         * through the printers would result in #printers x #requests
         * steps, whereas this entails #requests steps.)
         */
        for (i = 0; PStatus != NULL && PStatus[i] != NULL; i++)
                PStatus[i]->nrequests = 0;

        for (prs = Request_List; prs != NULL; prs = prs->next)
                if ((prs->pwheel_name != NULL) &&
                    (STREQU(prs->pwheel_name, pwheel_name)) &&
                    ((pps = prs->printer) != NULL) && pps->printer->daisy &&
                    (!SAME(pps->pwheel_name, pwheel_name)))
                        if (++pps->nrequests >= max)
                                max = pps->nrequests;

        if (NewRequest)
                if (
                        ((pps = NewRequest->printer) != NULL)
                     && pps->printer->daisy
                     && !SAME(pps->pwheel_name, pwheel_name)
                )
                        if (++pps->nrequests >= max)
                                max = pps->nrequests;
        return (max);
}

/**
 ** one_printer_with_charsets()
 **/

int
one_printer_with_charsets(RSTATUS *prs)
{
        /*
         * This little function answers the question: Is a request
         * that needs a character set destined for a particular
         * printer that has selectable character sets instead of
         * mountable print wheels?
         */
        return (
            STREQU(prs->request->destination, prs->printer->printer->name)
         && !prs->printer->printer->daisy
        );
}