001package jmri.jmrit.operations.trains.trainbuilder;
002
003import java.awt.*;
004import java.io.PrintWriter;
005import java.text.MessageFormat;
006import java.text.SimpleDateFormat;
007import java.util.*;
008import java.util.List;
009
010import javax.swing.JLabel;
011
012import org.slf4j.Logger;
013import org.slf4j.LoggerFactory;
014
015import com.fasterxml.jackson.databind.util.StdDateFormat;
016
017import jmri.InstanceManager;
018import jmri.jmrit.operations.locations.*;
019import jmri.jmrit.operations.locations.divisions.DivisionManager;
020import jmri.jmrit.operations.rollingstock.RollingStock;
021import jmri.jmrit.operations.rollingstock.cars.*;
022import jmri.jmrit.operations.rollingstock.engines.*;
023import jmri.jmrit.operations.routes.RouteLocation;
024import jmri.jmrit.operations.setup.Control;
025import jmri.jmrit.operations.setup.Setup;
026import jmri.jmrit.operations.trains.*;
027import jmri.util.ColorUtil;
028
029/**
030 * Common routines for trains
031 *
032 * @author Daniel Boudreau (C) Copyright 2008, 2009, 2010, 2011, 2012, 2013,
033 *         2021, 2025
034 */
035public class TrainCommon {
036
037    protected static final String TAB = "    "; // NOI18N
038    protected static final String NEW_LINE = "\n"; // NOI18N
039    public static final String SPACE = " ";
040    public static final String BLANK_LINE = " ";
041    protected static final char HORIZONTAL_LINE_CHAR = '-';
042    protected static final String BUILD_REPORT_CHAR = "-";
043    public static final String HYPHEN = "-";
044    protected static final char VERTICAL_LINE_CHAR = '|';
045    protected static final String TEXT_COLOR_START = "<FONT color=\"";
046    protected static final String TEXT_COLOR_DONE = "\">";
047    protected static final String TEXT_COLOR_END = "</FONT>";
048
049    // when true a pick up, when false a set out
050    protected static final boolean PICKUP = true;
051    // when true Manifest, when false switch list
052    protected static final boolean IS_MANIFEST = true;
053    // when true local car move
054    public static final boolean LOCAL = true;
055    // when true engine attribute, when false car
056    protected static final boolean ENGINE = true;
057    // when true, two column table is sorted by track names
058    public static final boolean IS_TWO_COLUMN_TRACK = true;
059
060    protected CarManager carManager = InstanceManager.getDefault(CarManager.class);
061    protected EngineManager engineManager = InstanceManager.getDefault(EngineManager.class);
062    protected LocationManager locationManager = InstanceManager.getDefault(LocationManager.class);
063
064    // for switch lists
065    protected boolean _pickupCars; // true when there are pickups
066    protected boolean _dropCars; // true when there are set outs
067
068    /**
069     * Used to generate "Two Column" format for engines.
070     *
071     * @param file       Manifest or Switch List File
072     * @param engineList List of engines for this train.
073     * @param rl         The RouteLocation being printed.
074     * @param isManifest True if manifest, false if switch list.
075     */
076    protected void blockLocosTwoColumn(PrintWriter file, List<Engine> engineList, RouteLocation rl,
077            boolean isManifest) {
078        if (isThereWorkAtLocation(null, engineList, rl)) {
079            printEngineHeader(file, isManifest);
080        }
081        int lineLength = getLineLength(isManifest);
082        for (Engine engine : engineList) {
083            if (engine.getRouteLocation() == rl && !engine.getTrackName().equals(Engine.NONE)) {
084                String pullText = padAndTruncate(pickupEngine(engine).trim(), lineLength / 2);
085                pullText = formatColorString(pullText, Setup.getPickupEngineColor());
086                String s = pullText + VERTICAL_LINE_CHAR + tabString("", lineLength / 2 - 1);
087                addLine(file, s);
088            }
089            if (engine.getRouteDestination() == rl) {
090                String dropText = padAndTruncate(dropEngine(engine).trim(), lineLength / 2 - 1);
091                dropText = formatColorString(dropText, Setup.getDropEngineColor());
092                String s = tabString("", lineLength / 2) + VERTICAL_LINE_CHAR + dropText;
093                addLine(file, s);
094            }
095        }
096    }
097
098    /**
099     * Adds a list of locomotive pick ups for the route location to the output
100     * file. Used to generate "Standard" format.
101     *
102     * @param file       Manifest or Switch List File
103     * @param engineList List of engines for this train.
104     * @param rl         The RouteLocation being printed.
105     * @param isManifest True if manifest, false if switch list
106     */
107    protected void pickupEngines(PrintWriter file, List<Engine> engineList, RouteLocation rl, boolean isManifest) {
108        boolean printHeader = Setup.isPrintHeadersEnabled();
109        for (Engine engine : engineList) {
110            if (engine.getRouteLocation() == rl && !engine.getTrackName().equals(Engine.NONE)) {
111                if (printHeader) {
112                    printPickupEngineHeader(file, isManifest);
113                    printHeader = false;
114                }
115                pickupEngine(file, engine, isManifest);
116            }
117        }
118    }
119
120    private void pickupEngine(PrintWriter file, Engine engine, boolean isManifest) {
121        StringBuffer buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getPickupEnginePrefix(),
122                isManifest ? Setup.getManifestPrefixLength() : Setup.getSwitchListPrefixLength()));
123        String[] format = Setup.getPickupEngineMessageFormat();
124        for (String attribute : format) {
125            String s = getEngineAttribute(engine, attribute, PICKUP);
126            if (!checkStringLength(buf.toString() + s, isManifest)) {
127                addLine(file, buf, Setup.getPickupEngineColor());
128                buf = new StringBuffer(TAB); // new line
129            }
130            buf.append(s);
131        }
132        addLine(file, buf, Setup.getPickupEngineColor());
133    }
134
135    /**
136     * Adds a list of locomotive drops for the route location to the output
137     * file. Used to generate "Standard" format.
138     *
139     * @param file       Manifest or Switch List File
140     * @param engineList List of engines for this train.
141     * @param rl         The RouteLocation being printed.
142     * @param isManifest True if manifest, false if switch list
143     */
144    protected void dropEngines(PrintWriter file, List<Engine> engineList, RouteLocation rl, boolean isManifest) {
145        boolean printHeader = Setup.isPrintHeadersEnabled();
146        for (Engine engine : engineList) {
147            if (engine.getRouteDestination() == rl) {
148                if (printHeader) {
149                    printDropEngineHeader(file, isManifest);
150                    printHeader = false;
151                }
152                dropEngine(file, engine, isManifest);
153            }
154        }
155    }
156
157    private void dropEngine(PrintWriter file, Engine engine, boolean isManifest) {
158        StringBuffer buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getDropEnginePrefix(),
159                isManifest ? Setup.getManifestPrefixLength() : Setup.getSwitchListPrefixLength()));
160        String[] format = Setup.getDropEngineMessageFormat();
161        for (String attribute : format) {
162            String s = getEngineAttribute(engine, attribute, !PICKUP);
163            if (!checkStringLength(buf.toString() + s, isManifest)) {
164                addLine(file, buf, Setup.getDropEngineColor());
165                buf = new StringBuffer(TAB); // new line
166            }
167            buf.append(s);
168        }
169        addLine(file, buf, Setup.getDropEngineColor());
170    }
171
172    /**
173     * Returns the pick up string for a loco. Useful for frames like the train
174     * conductor and yardmaster.
175     *
176     * @param engine The Engine.
177     * @return engine pick up string
178     */
179    public String pickupEngine(Engine engine) {
180        StringBuilder builder = new StringBuilder();
181        for (String attribute : Setup.getPickupEngineMessageFormat()) {
182            builder.append(getEngineAttribute(engine, attribute, PICKUP));
183        }
184        return builder.toString();
185    }
186
187    /**
188     * Returns the drop string for a loco. Useful for frames like the train
189     * conductor and yardmaster.
190     *
191     * @param engine The Engine.
192     * @return engine drop string
193     */
194    public String dropEngine(Engine engine) {
195        StringBuilder builder = new StringBuilder();
196        for (String attribute : Setup.getDropEngineMessageFormat()) {
197            builder.append(getEngineAttribute(engine, attribute, !PICKUP));
198        }
199        return builder.toString();
200    }
201
202    // the next three booleans are used to limit the header to once per location
203    boolean _printPickupHeader = true;
204    boolean _printSetoutHeader = true;
205    boolean _printLocalMoveHeader = true;
206
207    /**
208     * Block cars by track, then pick up and set out for each location in a
209     * train's route. This routine is used for the "Standard" format.
210     *
211     * @param file        Manifest or switch list File
212     * @param train       The train being printed.
213     * @param carList     List of cars for this train
214     * @param rl          The RouteLocation being printed
215     * @param printHeader True if new location.
216     * @param isManifest  True if manifest, false if switch list.
217     */
218    protected void blockCarsByTrack(PrintWriter file, Train train, List<Car> carList, RouteLocation rl,
219            boolean printHeader, boolean isManifest) {
220        if (printHeader) {
221            _printPickupHeader = true;
222            _printSetoutHeader = true;
223            _printLocalMoveHeader = true;
224        }
225        List<Track> tracks = rl.getLocation().getTracksByNameList(null);
226        List<String> trackNames = new ArrayList<>();
227        clearUtilityCarTypes(); // list utility cars by quantity
228        for (Track track : tracks) {
229            if (trackNames.contains(track.getSplitName())) {
230                continue;
231            }
232            trackNames.add(track.getSplitName()); // use a track name once
233
234            // car pick ups
235            blockCarsPickups(file, train, carList, rl, track, isManifest);
236
237            // now do car set outs and local moves
238            // group local moves first?
239            blockCarsSetoutsAndMoves(file, train, carList, rl, track, isManifest, false,
240                    Setup.isGroupCarMovesEnabled());
241            // set outs or both
242            blockCarsSetoutsAndMoves(file, train, carList, rl, track, isManifest, true,
243                    !Setup.isGroupCarMovesEnabled());
244
245            if (!Setup.isSortByTrackNameEnabled()) {
246                break; // done
247            }
248        }
249    }
250
251    private void blockCarsPickups(PrintWriter file, Train train, List<Car> carList, RouteLocation rl,
252            Track track, boolean isManifest) {
253        // block pick up cars, except for passenger cars
254        for (RouteLocation rld : train.getTrainBlockingOrder()) {
255            for (Car car : carList) {
256                if (Setup.isSortByTrackNameEnabled() &&
257                        !track.getSplitName().equals(car.getSplitTrackName())) {
258                    continue;
259                }
260                // Block cars
261                // caboose or FRED is placed at end of the train
262                // passenger cars are already blocked in the car list
263                // passenger cars with negative block numbers are placed at
264                // the front of the train, positive numbers at the end of
265                // the train.
266                if (isNextCar(car, rl, rld)) {
267                    // determine if pick up header is needed
268                    printPickupCarHeader(file, car, isManifest, !IS_TWO_COLUMN_TRACK);
269
270                    // use truncated format if there's a switch list
271                    boolean isTruncate = Setup.isPrintTruncateManifestEnabled() &&
272                            rl.getLocation().isSwitchListEnabled();
273
274                    if (car.isUtility()) {
275                        pickupUtilityCars(file, carList, car, isTruncate, isManifest);
276                    } else if (isManifest && isTruncate) {
277                        pickUpCarTruncated(file, car, isManifest);
278                    } else {
279                        pickUpCar(file, car, isManifest);
280                    }
281                    _pickupCars = true;
282                }
283            }
284        }
285    }
286
287    private void blockCarsSetoutsAndMoves(PrintWriter file, Train train, List<Car> carList, RouteLocation rl,
288            Track track, boolean isManifest, boolean isSetout, boolean isLocalMove) {
289        for (Car car : carList) {
290            if (!car.isLocalMove() && isSetout || car.isLocalMove() && isLocalMove) {
291                if (Setup.isSortByTrackNameEnabled() &&
292                        car.getRouteLocation() != null &&
293                        car.getRouteDestination() == rl) {
294                    // must sort local moves by car's destination track name and not car's track name
295                    // sorting by car's track name fails if there are "similar" location names.
296                    if (!track.getSplitName().equals(car.getSplitDestinationTrackName())) {
297                        continue;
298                    }
299                }
300                if (car.getRouteDestination() == rl && car.getDestinationTrack() != null) {
301                    // determine if drop or move header is needed
302                    printDropOrMoveCarHeader(file, car, isManifest, !IS_TWO_COLUMN_TRACK);
303
304                    // use truncated format if there's a switch list
305                    boolean isTruncate = Setup.isPrintTruncateManifestEnabled() &&
306                            rl.getLocation().isSwitchListEnabled() &&
307                            !train.isLocalSwitcher();
308
309                    if (car.isUtility()) {
310                        setoutUtilityCars(file, carList, car, isTruncate, isManifest);
311                    } else if (isManifest && isTruncate) {
312                        truncatedDropCar(file, car, isManifest);
313                    } else {
314                        dropCar(file, car, isManifest);
315                    }
316                    _dropCars = true;
317                }
318            }
319        }
320    }
321
322    /**
323     * Used to determine if car is the next to be processed when producing
324     * Manifests or Switch Lists. Caboose or FRED is placed at end of the train.
325     * Passenger cars are already blocked in the car list. Passenger cars with
326     * negative block numbers are placed at the front of the train, positive
327     * numbers at the end of the train. Note that a car in train doesn't have a
328     * track assignment.
329     * 
330     * @param car the car being tested
331     * @param rl  when in train's route the car is being pulled
332     * @param rld the destination being tested
333     * @return true if this car is the next one to be processed
334     */
335    public static boolean isNextCar(Car car, RouteLocation rl, RouteLocation rld) {
336        return isNextCar(car, rl, rld, false);
337    }
338        
339    public static boolean isNextCar(Car car, RouteLocation rl, RouteLocation rld, boolean isIgnoreTrack) {
340        Train train = car.getTrain();
341        if (train != null &&
342                (car.getTrack() != null || isIgnoreTrack) &&
343                car.getRouteLocation() == rl &&
344                (rld == car.getRouteDestination() &&
345                        !car.isCaboose() &&
346                        !car.hasFred() &&
347                        !car.isPassenger() ||
348                        rld == train.getTrainDepartsRouteLocation() &&
349                                car.isPassenger() &&
350                                car.getBlocking() < 0 ||
351                        rld == train.getTrainTerminatesRouteLocation() &&
352                                (car.isCaboose() ||
353                                        car.hasFred() ||
354                                        car.isPassenger() && car.getBlocking() >= 0))) {
355            return true;
356        }
357        return false;
358    }
359
360    private void printPickupCarHeader(PrintWriter file, Car car, boolean isManifest, boolean isTwoColumnTrack) {
361        if (_printPickupHeader && !car.isLocalMove()) {
362            printPickupCarHeader(file, isManifest, !IS_TWO_COLUMN_TRACK);
363            _printPickupHeader = false;
364            // check to see if the other headers are needed. If
365            // they are identical, not needed
366            if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK)
367                    .equals(getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK))) {
368                _printSetoutHeader = false;
369            }
370            if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK)
371                    .equals(getLocalMoveHeader(isManifest))) {
372                _printLocalMoveHeader = false;
373            }
374        }
375    }
376
377    private void printDropOrMoveCarHeader(PrintWriter file, Car car, boolean isManifest, boolean isTwoColumnTrack) {
378        if (_printSetoutHeader && !car.isLocalMove()) {
379            printDropCarHeader(file, isManifest, !IS_TWO_COLUMN_TRACK);
380            _printSetoutHeader = false;
381            // check to see if the other headers are needed. If they
382            // are identical, not needed
383            if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK)
384                    .equals(getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK))) {
385                _printPickupHeader = false;
386            }
387            if (getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK).equals(getLocalMoveHeader(isManifest))) {
388                _printLocalMoveHeader = false;
389            }
390        }
391        if (_printLocalMoveHeader && car.isLocalMove()) {
392            printLocalCarMoveHeader(file, isManifest);
393            _printLocalMoveHeader = false;
394            // check to see if the other headers are needed. If they
395            // are identical, not needed
396            if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK)
397                    .equals(getLocalMoveHeader(isManifest))) {
398                _printPickupHeader = false;
399            }
400            if (getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK).equals(getLocalMoveHeader(isManifest))) {
401                _printSetoutHeader = false;
402            }
403        }
404    }
405
406    /**
407     * Produces a two column format for car pick ups and set outs. Sorted by
408     * track and then by blocking order. This routine is used for the "Two
409     * Column" format.
410     *
411     * @param file        Manifest or switch list File
412     * @param train       The train
413     * @param carList     List of cars for this train
414     * @param rl          The RouteLocation being printed
415     * @param printHeader True if new location.
416     * @param isManifest  True if manifest, false if switch list.
417     */
418    protected void blockCarsTwoColumn(PrintWriter file, Train train, List<Car> carList, RouteLocation rl,
419            boolean printHeader, boolean isManifest) {
420        index = 0;
421        int lineLength = getLineLength(isManifest);
422        List<Track> tracks = rl.getLocation().getTracksByNameList(null);
423        List<String> trackNames = new ArrayList<>();
424        clearUtilityCarTypes(); // list utility cars by quantity
425        if (printHeader) {
426            printCarHeader(file, isManifest, !IS_TWO_COLUMN_TRACK);
427        }
428        for (Track track : tracks) {
429            if (trackNames.contains(track.getSplitName())) {
430                continue;
431            }
432            trackNames.add(track.getSplitName()); // use a track name once
433            // block car pick ups
434            for (RouteLocation rld : train.getTrainBlockingOrder()) {
435                for (int k = 0; k < carList.size(); k++) {
436                    Car car = carList.get(k);
437                    // block cars
438                    // caboose or FRED is placed at end of the train
439                    // passenger cars are already blocked in the car list
440                    // passenger cars with negative block numbers are placed at
441                    // the front of the train, positive numbers at the end of
442                    // the train.
443                    if (isNextCar(car, rl, rld)) {
444                        if (Setup.isSortByTrackNameEnabled() &&
445                                !track.getSplitName().equals(car.getSplitTrackName())) {
446                            continue;
447                        }
448                        _pickupCars = true;
449                        String s;
450                        if (car.isUtility()) {
451                            s = pickupUtilityCars(carList, car, isManifest, !IS_TWO_COLUMN_TRACK);
452                            if (s == null) {
453                                continue;
454                            }
455                            s = s.trim();
456                        } else {
457                            s = pickupCar(car, isManifest, !IS_TWO_COLUMN_TRACK).trim();
458                        }
459                        s = padAndTruncate(s, lineLength / 2);
460                        if (car.isLocalMove()) {
461                            s = formatColorString(s, Setup.getLocalColor());
462                            String sl = appendSetoutString(s, carList, car.getRouteDestination(), car, isManifest,
463                                    !IS_TWO_COLUMN_TRACK);
464                            // check for utility car, and local route with two
465                            // or more locations
466                            if (!sl.equals(s)) {
467                                s = sl;
468                                carList.remove(car); // done with this car, remove from list
469                                k--;
470                            } else {
471                                s = padAndTruncate(s + VERTICAL_LINE_CHAR, getLineLength(isManifest));
472                            }
473                        } else {
474                            s = formatColorString(s, Setup.getPickupColor());
475                            s = appendSetoutString(s, carList, rl, true, isManifest, !IS_TWO_COLUMN_TRACK);
476                        }
477                        addLine(file, s);
478                    }
479                }
480            }
481            if (!Setup.isSortByTrackNameEnabled()) {
482                break; // done
483            }
484        }
485        while (index < carList.size()) {
486            String s = padString("", lineLength / 2);
487            s = appendSetoutString(s, carList, rl, false, isManifest, !IS_TWO_COLUMN_TRACK);
488            String test = s.trim();
489            // null line contains |
490            if (test.length() > 1) {
491                addLine(file, s);
492            }
493        }
494    }
495
496    List<Car> doneCars = new ArrayList<>();
497
498    /**
499     * Produces a two column format for car pick ups and set outs. Sorted by
500     * track and then by destination. Track name in header format, track name
501     * removed from format. This routine is used to generate the "Two Column by
502     * Track" format.
503     *
504     * @param file        Manifest or switch list File
505     * @param train       The train
506     * @param carList     List of cars for this train
507     * @param rl          The RouteLocation being printed
508     * @param printHeader True if new location.
509     * @param isManifest  True if manifest, false if switch list.
510     */
511    protected void blockCarsByTrackNameTwoColumn(PrintWriter file, Train train, List<Car> carList, RouteLocation rl,
512            boolean printHeader, boolean isManifest) {
513        index = 0;
514        List<Track> tracks = rl.getLocation().getTracksByNameList(null);
515        List<String> trackNames = new ArrayList<>();
516        doneCars.clear();
517        clearUtilityCarTypes(); // list utility cars by quantity
518        if (printHeader) {
519            printCarHeader(file, isManifest, IS_TWO_COLUMN_TRACK);
520        }
521        for (Track track : tracks) {
522            String trackName = track.getSplitName();
523            if (trackNames.contains(trackName)) {
524                continue;
525            }
526            // block car pick ups
527            for (RouteLocation rld : train.getTrainBlockingOrder()) {
528                for (Car car : carList) {
529                    if (car.getTrack() != null &&
530                            car.getRouteLocation() == rl &&
531                            trackName.equals(car.getSplitTrackName()) &&
532                            ((car.getRouteDestination() == rld && !car.isCaboose() && !car.hasFred()) ||
533                                    (rld == train.getTrainTerminatesRouteLocation() &&
534                                            (car.isCaboose() || car.hasFred())))) {
535                        if (!trackNames.contains(trackName)) {
536                            printTrackNameHeader(file, trackName, isManifest);
537                        }
538                        trackNames.add(trackName); // use a track name once
539                        _pickupCars = true;
540                        String s;
541                        if (car.isUtility()) {
542                            s = pickupUtilityCars(carList, car, isManifest, IS_TWO_COLUMN_TRACK);
543                            if (s == null) {
544                                continue;
545                            }
546                            s = s.trim();
547                        } else {
548                            s = pickupCar(car, isManifest, IS_TWO_COLUMN_TRACK).trim();
549                        }
550                        s = padAndTruncate(s, getLineLength(isManifest) / 2);
551                        s = formatColorString(s, car.isLocalMove() ? Setup.getLocalColor() : Setup.getPickupColor());
552                        s = appendSetoutString(s, trackName, carList, rl, isManifest, IS_TWO_COLUMN_TRACK);
553                        addLine(file, s);
554                    }
555                }
556            }
557            for (Car car : carList) {
558                if (!doneCars.contains(car) &&
559                        car.getRouteDestination() == rl &&
560                        trackName.equals(car.getSplitDestinationTrackName())) {
561                    if (!trackNames.contains(trackName)) {
562                        printTrackNameHeader(file, trackName, isManifest);
563                    }
564                    trackNames.add(trackName); // use a track name once
565                    String s = padString("", getLineLength(isManifest) / 2);
566                    String so = appendSetoutString(s, carList, rl, car, isManifest, IS_TWO_COLUMN_TRACK);
567                    // check for utility car
568                    if (so.equals(s)) {
569                        continue;
570                    }
571                    String test = so.trim();
572                    if (test.length() > 1) // null line contains |
573                    {
574                        addLine(file, so);
575                    }
576                }
577            }
578        }
579    }
580
581    protected void printTrackComments(PrintWriter file, RouteLocation rl, List<Car> carList, boolean isManifest) {
582        Location location = rl.getLocation();
583        if (location != null) {
584            List<Track> tracks = location.getTracksByNameList(null);
585            for (Track track : tracks) {
586                if (isManifest && !track.isPrintManifestCommentEnabled() ||
587                        !isManifest && !track.isPrintSwitchListCommentEnabled()) {
588                    continue;
589                }
590                // any pick ups or set outs to this track?
591                boolean pickup = false;
592                boolean setout = false;
593                for (Car car : carList) {
594                    if (car.getRouteLocation() == rl && car.getTrack() != null && car.getTrack() == track) {
595                        pickup = true;
596                    }
597                    if (car.getRouteDestination() == rl &&
598                            car.getDestinationTrack() != null &&
599                            car.getDestinationTrack() == track) {
600                        setout = true;
601                    }
602                }
603                // print the appropriate comment if there's one
604                if (pickup && setout && !track.getCommentBothWithColor().equals(Track.NONE)) {
605                    newLine(file, track.getCommentBothWithColor(), isManifest);
606                } else if (pickup && !setout && !track.getCommentPickupWithColor().equals(Track.NONE)) {
607                    newLine(file, track.getCommentPickupWithColor(), isManifest);
608                } else if (!pickup && setout && !track.getCommentSetoutWithColor().equals(Track.NONE)) {
609                    newLine(file, track.getCommentSetoutWithColor(), isManifest);
610                }
611            }
612        }
613    }
614
615    protected void setCarPickupAndSetoutTimes(Train train, RouteLocation rl, List<Car> carList) {
616        String expectedDepartureTime = train.getExpectedDepartureTime(rl, true);
617        for (Car car : carList) {
618            if (car.getRouteLocation() == rl) {
619                car.setPickupTime(expectedDepartureTime);
620            }
621            if (car.getRouteDestination() == rl) {
622                car.setSetoutTime(expectedDepartureTime);
623            }
624        }
625
626    }
627
628    @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "SLF4J_FORMAT_SHOULD_BE_CONST",
629            justification = "Only when exception")
630    public static String getTrainMessage(Train train, RouteLocation rl) {
631        String expectedArrivalTime = train.getExpectedArrivalTime(rl);
632        String routeLocationName = rl.getSplitName();
633        String msg = "";
634        String messageFormatText = ""; // the text being formated in case there's an exception
635        try {
636            // Scheduled work at {0}
637            msg = MessageFormat.format(messageFormatText = TrainManifestText
638                    .getStringScheduledWork(),
639                    new Object[]{routeLocationName, train.getSplitName(),
640                            train.getDescription(), rl.getLocation().getDivisionName()});
641            if (train.isShowArrivalAndDepartureTimesEnabled()) {
642                if (rl == train.getTrainDepartsRouteLocation()) {
643                    // Scheduled work at {0}, departure time {1}
644                    msg = MessageFormat.format(messageFormatText = TrainManifestText
645                            .getStringWorkDepartureTime(),
646                            new Object[]{routeLocationName,
647                                    train.getFormatedDepartureTime(), train.getSplitName(),
648                                    train.getDescription(), rl.getLocation().getDivisionName()});
649                } else if (!rl.getDepartureTime().equals(RouteLocation.NONE) &&
650                        rl != train.getTrainTerminatesRouteLocation()) {
651                    // Scheduled work at {0}, departure time {1}
652                    msg = MessageFormat.format(messageFormatText = TrainManifestText
653                            .getStringWorkDepartureTime(),
654                            new Object[]{routeLocationName,
655                                    expectedArrivalTime.equals(Train.ALREADY_SERVICED)
656                                            ? rl.getFormatedDepartureTime() : train.getExpectedDepartureTime(rl),
657                                    train.getSplitName(), train.getDescription(),
658                                    rl.getLocation().getDivisionName()});
659                } else if (Setup.isUseDepartureTimeEnabled() &&
660                        rl != train.getTrainTerminatesRouteLocation() &&
661                        !train.getExpectedDepartureTime(rl).equals(Train.ALREADY_SERVICED)) {
662                    // Scheduled work at {0}, departure time {1}
663                    msg = MessageFormat.format(messageFormatText = TrainManifestText
664                            .getStringWorkDepartureTime(),
665                            new Object[]{routeLocationName,
666                                    train.getExpectedDepartureTime(rl), train.getSplitName(),
667                                    train.getDescription(), rl.getLocation().getDivisionName()});
668                } else if (!expectedArrivalTime.equals(Train.ALREADY_SERVICED)) {
669                    // Scheduled work at {0}, arrival time {1}
670                    msg = MessageFormat.format(messageFormatText = TrainManifestText
671                            .getStringWorkArrivalTime(),
672                            new Object[]{routeLocationName, expectedArrivalTime,
673                                    train.getSplitName(), train.getDescription(),
674                                    rl.getLocation().getDivisionName()});
675                }
676            }
677            return msg;
678        } catch (IllegalArgumentException e) {
679            msg = Bundle.getMessage("ErrorIllegalArgument",
680                    Bundle.getMessage("TitleManifestText"), e.getLocalizedMessage()) + NEW_LINE + messageFormatText;
681            log.error(msg);
682            log.error("Illegal argument", e);
683            return msg;
684        }
685    }
686
687    @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "SLF4J_FORMAT_SHOULD_BE_CONST",
688            justification = "Only when exception")
689    public static String getSwitchListTrainStatus(Train train, RouteLocation rl) {
690        String expectedArrivalTime = train.getExpectedArrivalTime(rl);
691        String msg = "";
692        String messageFormatText = ""; // the text being formated in case there's an exception
693        try {
694            if (train.isLocalSwitcher()) {
695                // Use Manifest text for local departure
696                // Scheduled work at {0}, departure time {1}
697                msg = MessageFormat.format(messageFormatText = TrainManifestText.getStringWorkDepartureTime(),
698                        new Object[]{splitString(train.getTrainDepartsName()), train.getFormatedDepartureTime(),
699                                train.getSplitName(), train.getDescription(),
700                                rl.getLocation().getDivisionName()});
701            } else if (rl == train.getTrainDepartsRouteLocation()) {
702                // Departs {0} {1}bound at {2}
703                msg = MessageFormat.format(messageFormatText = TrainSwitchListText.getStringDepartsAt(),
704                        new Object[]{splitString(train.getTrainDepartsName()), rl.getTrainDirectionString(),
705                                train.getFormatedDepartureTime()});
706            } else if (Setup.isUseSwitchListDepartureTimeEnabled() &&
707                    rl != train.getTrainTerminatesRouteLocation() &&
708                    !train.isTrainEnRoute()) {
709                // Departs {0} at {1} expected arrival {2}, arrives {3}bound
710                msg = MessageFormat.format(
711                        messageFormatText = TrainSwitchListText.getStringDepartsAtExpectedArrival(),
712                        new Object[]{splitString(rl.getName()),
713                                train.getExpectedDepartureTime(rl), expectedArrivalTime,
714                                rl.getTrainDirectionString()});
715            } else if (Setup.isUseSwitchListDepartureTimeEnabled() &&
716                    rl == train.getCurrentRouteLocation() &&
717                    rl != train.getTrainTerminatesRouteLocation() &&
718                    !rl.getDepartureTime().equals(RouteLocation.NONE)) {
719                // Departs {0} {1}bound at {2}
720                msg = MessageFormat.format(messageFormatText = TrainSwitchListText.getStringDepartsAt(),
721                        new Object[]{splitString(rl.getName()), rl.getTrainDirectionString(),
722                                rl.getFormatedDepartureTime()});
723            } else if (train.isTrainEnRoute()) {
724                if (!expectedArrivalTime.equals(Train.ALREADY_SERVICED)) {
725                    // Departed {0}, expect to arrive in {1}, arrives {2}bound
726                    msg = MessageFormat.format(messageFormatText = TrainSwitchListText.getStringDepartedExpected(),
727                            new Object[]{splitString(train.getTrainDepartsName()), expectedArrivalTime,
728                                    rl.getTrainDirectionString(), train.getCurrentLocationName()});
729                }
730            } else {
731                // Departs {0} at {1} expected arrival {2}, arrives {3}bound
732                msg = MessageFormat.format(
733                        messageFormatText = TrainSwitchListText.getStringDepartsAtExpectedArrival(),
734                        new Object[]{splitString(train.getTrainDepartsName()),
735                                train.getFormatedDepartureTime(), expectedArrivalTime,
736                                rl.getTrainDirectionString()});
737            }
738            return msg;
739        } catch (IllegalArgumentException e) {
740            msg = Bundle.getMessage("ErrorIllegalArgument",
741                    Bundle.getMessage("TitleSwitchListText"), e.getLocalizedMessage()) + NEW_LINE + messageFormatText;
742            log.error(msg);
743            log.error("Illegal argument", e);
744            return msg;
745        }
746    }
747
748    int index = 0;
749
750    /*
751     * Used by two column format. Local moves (pulls and spots) are lined up
752     * when using this format,
753     */
754    private String appendSetoutString(String s, List<Car> carList, RouteLocation rl, boolean local, boolean isManifest,
755            boolean isTwoColumnTrack) {
756        while (index < carList.size()) {
757            Car car = carList.get(index++);
758            if (local && car.isLocalMove()) {
759                continue; // skip local moves
760            }
761            // car list is already sorted by destination track
762            if (car.getRouteDestination() == rl) {
763                String so = appendSetoutString(s, carList, rl, car, isManifest, isTwoColumnTrack);
764                // check for utility car
765                if (!so.equals(s)) {
766                    return so;
767                }
768            }
769        }
770        // no set out for this line
771        return s + VERTICAL_LINE_CHAR + padAndTruncate("", getLineLength(isManifest) / 2 - 1);
772    }
773
774    /*
775     * Used by two column, track names shown in the columns.
776     */
777    private String appendSetoutString(String s, String trackName, List<Car> carList, RouteLocation rl,
778            boolean isManifest, boolean isTwoColumnTrack) {
779        for (Car car : carList) {
780            if (!doneCars.contains(car) &&
781                    car.getRouteDestination() == rl &&
782                    trackName.equals(car.getSplitDestinationTrackName())) {
783                doneCars.add(car);
784                String so = appendSetoutString(s, carList, rl, car, isManifest, isTwoColumnTrack);
785                // check for utility car
786                if (!so.equals(s)) {
787                    return so;
788                }
789            }
790        }
791        // no set out for this track
792        return s + VERTICAL_LINE_CHAR + padAndTruncate("", getLineLength(isManifest) / 2 - 1);
793    }
794
795    /*
796     * Appends to string the vertical line character, and the car set out
797     * string. Used in two column format.
798     */
799    private String appendSetoutString(String s, List<Car> carList, RouteLocation rl, Car car, boolean isManifest,
800            boolean isTwoColumnTrack) {
801        _dropCars = true;
802        String dropText;
803
804        if (car.isUtility()) {
805            dropText = setoutUtilityCars(carList, car, !LOCAL, isManifest, isTwoColumnTrack);
806            if (dropText == null) {
807                return s; // no changes to the input string
808            }
809        } else {
810            dropText = dropCar(car, isManifest, isTwoColumnTrack).trim();
811        }
812
813        dropText = padAndTruncate(dropText.trim(), getLineLength(isManifest) / 2 - 1);
814        dropText = formatColorString(dropText, car.isLocalMove() ? Setup.getLocalColor() : Setup.getDropColor());
815        return s + VERTICAL_LINE_CHAR + dropText;
816    }
817
818    /**
819     * Adds the car's pick up string to the output file using the truncated
820     * manifest format
821     *
822     * @param file       Manifest or switch list File
823     * @param car        The car being printed.
824     * @param isManifest True if manifest, false if switch list.
825     */
826    protected void pickUpCarTruncated(PrintWriter file, Car car, boolean isManifest) {
827        pickUpCar(file, car,
828                new StringBuffer(padAndTruncateIfNeeded(Setup.getPickupCarPrefix(), Setup.getManifestPrefixLength())),
829                Setup.getPickupTruncatedManifestMessageFormat(), isManifest);
830    }
831
832    /**
833     * Adds the car's pick up string to the output file using the manifest or
834     * switch list format
835     *
836     * @param file       Manifest or switch list File
837     * @param car        The car being printed.
838     * @param isManifest True if manifest, false if switch list.
839     */
840    protected void pickUpCar(PrintWriter file, Car car, boolean isManifest) {
841        if (isManifest) {
842            pickUpCar(file, car,
843                    new StringBuffer(
844                            padAndTruncateIfNeeded(Setup.getPickupCarPrefix(), Setup.getManifestPrefixLength())),
845                    Setup.getPickupManifestMessageFormat(), isManifest);
846        } else {
847            pickUpCar(file, car, new StringBuffer(
848                    padAndTruncateIfNeeded(Setup.getSwitchListPickupCarPrefix(), Setup.getSwitchListPrefixLength())),
849                    Setup.getPickupSwitchListMessageFormat(), isManifest);
850        }
851    }
852
853    private void pickUpCar(PrintWriter file, Car car, StringBuffer buf, String[] format, boolean isManifest) {
854        if (car.isLocalMove()) {
855            return; // print nothing local move, see dropCar
856        }
857        for (String attribute : format) {
858            String s = getCarAttribute(car, attribute, PICKUP, !LOCAL);
859            if (!checkStringLength(buf.toString() + s, isManifest)) {
860                addLine(file, buf, Setup.getPickupColor());
861                buf = new StringBuffer(TAB); // new line
862            }
863            buf.append(s);
864        }
865        addLine(file, buf, Setup.getPickupColor());
866    }
867
868    /**
869     * Returns the pick up car string. Useful for frames like train conductor
870     * and yardmaster.
871     *
872     * @param car              The car being printed.
873     * @param isManifest       when true use manifest format, when false use
874     *                         switch list format
875     * @param isTwoColumnTrack True if printing using two column format sorted
876     *                         by track name.
877     * @return pick up car string
878     */
879    public String pickupCar(Car car, boolean isManifest, boolean isTwoColumnTrack) {
880        StringBuffer buf = new StringBuffer();
881        String[] format;
882        if (isManifest && !isTwoColumnTrack) {
883            format = Setup.getPickupManifestMessageFormat();
884        } else if (!isManifest && !isTwoColumnTrack) {
885            format = Setup.getPickupSwitchListMessageFormat();
886        } else if (isManifest && isTwoColumnTrack) {
887            format = Setup.getPickupTwoColumnByTrackManifestMessageFormat();
888        } else {
889            format = Setup.getPickupTwoColumnByTrackSwitchListMessageFormat();
890        }
891        for (String attribute : format) {
892            buf.append(getCarAttribute(car, attribute, PICKUP, !LOCAL));
893        }
894        return buf.toString();
895    }
896
897    /**
898     * Adds the car's set out string to the output file using the truncated
899     * manifest format. Does not print out local moves. Local moves are only
900     * shown on the switch list for that location.
901     *
902     * @param file       Manifest or switch list File
903     * @param car        The car being printed.
904     * @param isManifest True if manifest, false if switch list.
905     */
906    protected void truncatedDropCar(PrintWriter file, Car car, boolean isManifest) {
907        // local move?
908        if (car.isLocalMove()) {
909            return; // yes, don't print local moves on train manifest
910        }
911        dropCar(file, car, new StringBuffer(Setup.getDropCarPrefix()), Setup.getDropTruncatedManifestMessageFormat(),
912                false, isManifest);
913    }
914
915    /**
916     * Adds the car's set out string to the output file using the manifest or
917     * switch list format
918     *
919     * @param file       Manifest or switch list File
920     * @param car        The car being printed.
921     * @param isManifest True if manifest, false if switch list.
922     */
923    protected void dropCar(PrintWriter file, Car car, boolean isManifest) {
924        boolean isLocal = car.isLocalMove();
925        if (isManifest) {
926            StringBuffer buf = new StringBuffer(
927                    padAndTruncateIfNeeded(Setup.getDropCarPrefix(), Setup.getManifestPrefixLength()));
928            String[] format = Setup.getDropManifestMessageFormat();
929            if (isLocal) {
930                buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getLocalPrefix(), Setup.getManifestPrefixLength()));
931                format = Setup.getLocalManifestMessageFormat();
932            }
933            dropCar(file, car, buf, format, isLocal, isManifest);
934        } else {
935            StringBuffer buf = new StringBuffer(
936                    padAndTruncateIfNeeded(Setup.getSwitchListDropCarPrefix(), Setup.getSwitchListPrefixLength()));
937            String[] format = Setup.getDropSwitchListMessageFormat();
938            if (isLocal) {
939                buf = new StringBuffer(
940                        padAndTruncateIfNeeded(Setup.getSwitchListLocalPrefix(), Setup.getSwitchListPrefixLength()));
941                format = Setup.getLocalSwitchListMessageFormat();
942            }
943            dropCar(file, car, buf, format, isLocal, isManifest);
944        }
945    }
946
947    private void dropCar(PrintWriter file, Car car, StringBuffer buf, String[] format, boolean isLocal,
948            boolean isManifest) {
949        for (String attribute : format) {
950            String s = getCarAttribute(car, attribute, !PICKUP, isLocal);
951            if (!checkStringLength(buf.toString() + s, isManifest)) {
952                addLine(file, buf, isLocal ? Setup.getLocalColor() : Setup.getDropColor());
953                buf = new StringBuffer(TAB); // new line
954            }
955            buf.append(s);
956        }
957        addLine(file, buf, isLocal ? Setup.getLocalColor() : Setup.getDropColor());
958    }
959
960    /**
961     * Returns the drop car string. Useful for frames like train conductor and
962     * yardmaster.
963     *
964     * @param car              The car being printed.
965     * @param isManifest       when true use manifest format, when false use
966     *                         switch list format
967     * @param isTwoColumnTrack True if printing using two column format.
968     * @return drop car string
969     */
970    public String dropCar(Car car, boolean isManifest, boolean isTwoColumnTrack) {
971        StringBuffer buf = new StringBuffer();
972        String[] format;
973        if (isManifest && !isTwoColumnTrack) {
974            format = Setup.getDropManifestMessageFormat();
975        } else if (!isManifest && !isTwoColumnTrack) {
976            format = Setup.getDropSwitchListMessageFormat();
977        } else if (isManifest && isTwoColumnTrack) {
978            format = Setup.getDropTwoColumnByTrackManifestMessageFormat();
979        } else {
980            format = Setup.getDropTwoColumnByTrackSwitchListMessageFormat();
981        }
982        // TODO the Setup.Location doesn't work correctly for the conductor
983        // window due to the fact that the car can be in the train and not
984        // at its starting location.
985        // Therefore we use the local true to disable it.
986        boolean local = false;
987        if (car.getTrack() == null) {
988            local = true;
989        }
990        for (String attribute : format) {
991            buf.append(getCarAttribute(car, attribute, !PICKUP, local));
992        }
993        return buf.toString();
994    }
995
996    /**
997     * Returns the move car string. Useful for frames like train conductor and
998     * yardmaster.
999     *
1000     * @param car        The car being printed.
1001     * @param isManifest when true use manifest format, when false use switch
1002     *                   list format
1003     * @return move car string
1004     */
1005    public String localMoveCar(Car car, boolean isManifest) {
1006        StringBuffer buf = new StringBuffer();
1007        String[] format;
1008        if (isManifest) {
1009            format = Setup.getLocalManifestMessageFormat();
1010        } else {
1011            format = Setup.getLocalSwitchListMessageFormat();
1012        }
1013        for (String attribute : format) {
1014            buf.append(getCarAttribute(car, attribute, !PICKUP, LOCAL));
1015        }
1016        return buf.toString();
1017    }
1018
1019    List<String> utilityCarTypes = new ArrayList<>();
1020    private static final int UTILITY_CAR_COUNT_FIELD_SIZE = 3;
1021
1022    /**
1023     * Add a list of utility cars scheduled for pick up from the route location
1024     * to the output file. The cars are blocked by destination.
1025     *
1026     * @param file       Manifest or Switch List File.
1027     * @param carList    List of cars for this train.
1028     * @param car        The utility car.
1029     * @param isTruncate True if manifest is to be truncated
1030     * @param isManifest True if manifest, false if switch list.
1031     */
1032    protected void pickupUtilityCars(PrintWriter file, List<Car> carList, Car car, boolean isTruncate,
1033            boolean isManifest) {
1034        // list utility cars by type, track, length, and load
1035        String[] format;
1036        if (isManifest) {
1037            format = Setup.getPickupUtilityManifestMessageFormat();
1038        } else {
1039            format = Setup.getPickupUtilitySwitchListMessageFormat();
1040        }
1041        if (isTruncate && isManifest) {
1042            format = Setup.createTruncatedManifestMessageFormat(format);
1043        }
1044        int count = countUtilityCars(format, carList, car, PICKUP);
1045        if (count == 0) {
1046            return; // already printed out this car type
1047        }
1048        pickUpCar(file, car,
1049                new StringBuffer(padAndTruncateIfNeeded(Setup.getPickupCarPrefix(),
1050                        isManifest ? Setup.getManifestPrefixLength() : Setup.getSwitchListPrefixLength()) +
1051                        SPACE +
1052                        padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE)),
1053                format, isManifest);
1054    }
1055
1056    /**
1057     * Add a list of utility cars scheduled for drop at the route location to
1058     * the output file.
1059     *
1060     * @param file       Manifest or Switch List File.
1061     * @param carList    List of cars for this train.
1062     * @param car        The utility car.
1063     * @param isTruncate True if manifest is to be truncated
1064     * @param isManifest True if manifest, false if switch list.
1065     */
1066    protected void setoutUtilityCars(PrintWriter file, List<Car> carList, Car car, boolean isTruncate,
1067            boolean isManifest) {
1068        boolean isLocal = car.isLocalMove();
1069        StringBuffer buf;
1070        String[] format;
1071        if (isLocal && isManifest) {
1072            buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getLocalPrefix(), Setup.getManifestPrefixLength()));
1073            format = Setup.getLocalUtilityManifestMessageFormat();
1074        } else if (!isLocal && isManifest) {
1075            buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getDropCarPrefix(), Setup.getManifestPrefixLength()));
1076            format = Setup.getDropUtilityManifestMessageFormat();
1077        } else if (isLocal && !isManifest) {
1078            buf = new StringBuffer(
1079                    padAndTruncateIfNeeded(Setup.getSwitchListLocalPrefix(), Setup.getSwitchListPrefixLength()));
1080            format = Setup.getLocalUtilitySwitchListMessageFormat();
1081        } else {
1082            buf = new StringBuffer(
1083                    padAndTruncateIfNeeded(Setup.getSwitchListDropCarPrefix(), Setup.getSwitchListPrefixLength()));
1084            format = Setup.getDropUtilitySwitchListMessageFormat();
1085        }
1086        if (isTruncate && isManifest) {
1087            format = Setup.createTruncatedManifestMessageFormat(format);
1088        }
1089
1090        int count = countUtilityCars(format, carList, car, !PICKUP);
1091        if (count == 0) {
1092            return; // already printed out this car type
1093        }
1094        buf.append(SPACE + padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE));
1095        dropCar(file, car, buf, format, isLocal, isManifest);
1096    }
1097
1098    public String pickupUtilityCars(List<Car> carList, Car car, boolean isManifest, boolean isTwoColumnTrack) {
1099        int count = countPickupUtilityCars(carList, car, isManifest);
1100        if (count == 0) {
1101            return null;
1102        }
1103        String[] format;
1104        if (isManifest && !isTwoColumnTrack) {
1105            format = Setup.getPickupUtilityManifestMessageFormat();
1106        } else if (!isManifest && !isTwoColumnTrack) {
1107            format = Setup.getPickupUtilitySwitchListMessageFormat();
1108        } else if (isManifest && isTwoColumnTrack) {
1109            format = Setup.getPickupTwoColumnByTrackUtilityManifestMessageFormat();
1110        } else {
1111            format = Setup.getPickupTwoColumnByTrackUtilitySwitchListMessageFormat();
1112        }
1113        StringBuffer buf = new StringBuffer(SPACE + padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE));
1114        for (String attribute : format) {
1115            buf.append(getCarAttribute(car, attribute, PICKUP, !LOCAL));
1116        }
1117        return buf.toString();
1118    }
1119
1120    public int countPickupUtilityCars(List<Car> carList, Car car, boolean isManifest) {
1121        // list utility cars by type, track, length, and load
1122        String[] format;
1123        if (isManifest) {
1124            format = Setup.getPickupUtilityManifestMessageFormat();
1125        } else {
1126            format = Setup.getPickupUtilitySwitchListMessageFormat();
1127        }
1128        return countUtilityCars(format, carList, car, PICKUP);
1129    }
1130
1131    /**
1132     * For the Conductor and Yardmaster windows.
1133     *
1134     * @param carList    List of cars for this train.
1135     * @param car        The utility car.
1136     * @param isLocal    True if local move.
1137     * @param isManifest True if manifest, false if switch list.
1138     * @return A string representing the work of identical utility cars.
1139     */
1140    public String setoutUtilityCars(List<Car> carList, Car car, boolean isLocal, boolean isManifest) {
1141        return setoutUtilityCars(carList, car, isLocal, isManifest, !IS_TWO_COLUMN_TRACK);
1142    }
1143
1144    protected String setoutUtilityCars(List<Car> carList, Car car, boolean isLocal, boolean isManifest,
1145            boolean isTwoColumnTrack) {
1146        int count = countSetoutUtilityCars(carList, car, isLocal, isManifest);
1147        if (count == 0) {
1148            return null;
1149        }
1150        // list utility cars by type, track, length, and load
1151        String[] format;
1152        if (isLocal && isManifest && !isTwoColumnTrack) {
1153            format = Setup.getLocalUtilityManifestMessageFormat();
1154        } else if (isLocal && !isManifest && !isTwoColumnTrack) {
1155            format = Setup.getLocalUtilitySwitchListMessageFormat();
1156        } else if (!isLocal && !isManifest && !isTwoColumnTrack) {
1157            format = Setup.getDropUtilitySwitchListMessageFormat();
1158        } else if (!isLocal && isManifest && !isTwoColumnTrack) {
1159            format = Setup.getDropUtilityManifestMessageFormat();
1160        } else if (isManifest && isTwoColumnTrack) {
1161            format = Setup.getDropTwoColumnByTrackUtilityManifestMessageFormat();
1162        } else {
1163            format = Setup.getDropTwoColumnByTrackUtilitySwitchListMessageFormat();
1164        }
1165        StringBuffer buf = new StringBuffer(SPACE + padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE));
1166        // TODO the Setup.Location doesn't work correctly for the conductor
1167        // window due to the fact that the car can be in the train and not
1168        // at its starting location.
1169        // Therefore we use the local true to disable it.
1170        if (car.getTrack() == null) {
1171            isLocal = true;
1172        }
1173        for (String attribute : format) {
1174            buf.append(getCarAttribute(car, attribute, !PICKUP, isLocal));
1175        }
1176        return buf.toString();
1177    }
1178
1179    public int countSetoutUtilityCars(List<Car> carList, Car car, boolean isLocal, boolean isManifest) {
1180        // list utility cars by type, track, length, and load
1181        String[] format;
1182        if (isLocal && isManifest) {
1183            format = Setup.getLocalUtilityManifestMessageFormat();
1184        } else if (isLocal && !isManifest) {
1185            format = Setup.getLocalUtilitySwitchListMessageFormat();
1186        } else if (!isLocal && !isManifest) {
1187            format = Setup.getDropUtilitySwitchListMessageFormat();
1188        } else {
1189            format = Setup.getDropUtilityManifestMessageFormat();
1190        }
1191        return countUtilityCars(format, carList, car, !PICKUP);
1192    }
1193
1194    /**
1195     * Scans the car list for utility cars that have the same attributes as the
1196     * car provided. Returns 0 if this car type has already been processed,
1197     * otherwise the number of cars with the same attribute.
1198     *
1199     * @param format   Message format.
1200     * @param carList  List of cars for this train
1201     * @param car      The utility car.
1202     * @param isPickup True if pick up, false if set out.
1203     * @return 0 if the car type has already been processed
1204     */
1205    protected int countUtilityCars(String[] format, List<Car> carList, Car car, boolean isPickup) {
1206        int count = 0;
1207        // figure out if the user wants to show the car's length
1208        boolean showLength = showUtilityCarLength(format);
1209        // figure out if the user want to show the car's loads
1210        boolean showLoad = showUtilityCarLoad(format);
1211        boolean showLocation = false;
1212        boolean showDestination = false;
1213        String carType = car.getTypeName().split(HYPHEN)[0];
1214        String carAttributes;
1215        // Note for car pick up: type, id, track name. For set out type, track
1216        // name, id (reversed).
1217        if (isPickup) {
1218            carAttributes = carType + car.getRouteLocationId() + car.getSplitTrackName();
1219            showDestination = showUtilityCarDestination(format);
1220            if (showDestination) {
1221                carAttributes = carAttributes + car.getRouteDestinationId();
1222            }
1223        } else {
1224            // set outs and local moves
1225            carAttributes = carType + car.getSplitDestinationTrackName() + car.getRouteDestinationId();
1226            showLocation = showUtilityCarLocation(format);
1227            if (showLocation && car.getTrack() != null) {
1228                carAttributes = carAttributes + car.getRouteLocationId();
1229            }
1230        }
1231        if (car.isLocalMove()) {
1232            carAttributes = carAttributes + car.getSplitTrackName();
1233        }
1234        if (showLength) {
1235            carAttributes = carAttributes + car.getLength();
1236        }
1237        if (showLoad) {
1238            carAttributes = carAttributes + car.getLoadName();
1239        }
1240        // have we already done this car type?
1241        if (!utilityCarTypes.contains(carAttributes)) {
1242            utilityCarTypes.add(carAttributes); // don't do this type again
1243            // determine how many cars of this type
1244            for (Car c : carList) {
1245                if (!c.isUtility()) {
1246                    continue;
1247                }
1248                String cType = c.getTypeName().split(HYPHEN)[0];
1249                if (!cType.equals(carType)) {
1250                    continue;
1251                }
1252                if (showLength && !c.getLength().equals(car.getLength())) {
1253                    continue;
1254                }
1255                if (showLoad && !c.getLoadName().equals(car.getLoadName())) {
1256                    continue;
1257                }
1258                if (showLocation && !c.getRouteLocationId().equals(car.getRouteLocationId())) {
1259                    continue;
1260                }
1261                if (showDestination && !c.getRouteDestinationId().equals(car.getRouteDestinationId())) {
1262                    continue;
1263                }
1264                if (car.isLocalMove() ^ c.isLocalMove()) {
1265                    continue;
1266                }
1267                if (isPickup &&
1268                        c.getRouteLocation() == car.getRouteLocation() &&
1269                        c.getSplitTrackName().equals(car.getSplitTrackName())) {
1270                    count++;
1271                }
1272                if (!isPickup &&
1273                        c.getRouteDestination() == car.getRouteDestination() &&
1274                        c.getSplitDestinationTrackName().equals(car.getSplitDestinationTrackName()) &&
1275                        (c.getSplitTrackName().equals(car.getSplitTrackName()) || !c.isLocalMove())) {
1276                    count++;
1277                }
1278            }
1279        }
1280        return count;
1281    }
1282
1283    public void clearUtilityCarTypes() {
1284        utilityCarTypes.clear();
1285    }
1286
1287    private boolean showUtilityCarLength(String[] mFormat) {
1288        return showUtilityCarAttribute(Setup.LENGTH, mFormat);
1289    }
1290
1291    private boolean showUtilityCarLoad(String[] mFormat) {
1292        return showUtilityCarAttribute(Setup.LOAD, mFormat);
1293    }
1294
1295    private boolean showUtilityCarLocation(String[] mFormat) {
1296        return showUtilityCarAttribute(Setup.LOCATION, mFormat);
1297    }
1298
1299    private boolean showUtilityCarDestination(String[] mFormat) {
1300        return showUtilityCarAttribute(Setup.DESTINATION, mFormat) ||
1301                showUtilityCarAttribute(Setup.DEST_TRACK, mFormat);
1302    }
1303
1304    private boolean showUtilityCarAttribute(String string, String[] mFormat) {
1305        for (String s : mFormat) {
1306            if (s.equals(string)) {
1307                return true;
1308            }
1309        }
1310        return false;
1311    }
1312
1313    /**
1314     * Writes a line to the build report file
1315     *
1316     * @param file   build report file
1317     * @param level  print level
1318     * @param string string to write
1319     */
1320    public static void addLine(PrintWriter file, String level, String string) {
1321        log.debug("addLine: {}", string);
1322        if (file != null) {
1323            String[] lines = string.split(NEW_LINE);
1324            for (String line : lines) {
1325                printLine(file, level, line);
1326            }
1327        }
1328    }
1329
1330    // only used by build report
1331    private static void printLine(PrintWriter file, String level, String string) {
1332        int lineLengthMax = getLineLength(Setup.PORTRAIT, Setup.MONOSPACED, Font.PLAIN, Setup.getBuildReportFontSize());
1333        if (string.length() > lineLengthMax) {
1334            String[] words = string.split(SPACE);
1335            StringBuffer sb = new StringBuffer();
1336            for (String word : words) {
1337                if (sb.length() + word.length() < lineLengthMax) {
1338                    sb.append(word + SPACE);
1339                } else {
1340                    file.println(level + BUILD_REPORT_CHAR + SPACE + sb.toString());
1341                    sb = new StringBuffer(word + SPACE);
1342                }
1343            }
1344            string = sb.toString();
1345        }
1346        file.println(level + BUILD_REPORT_CHAR + SPACE + string);
1347    }
1348
1349    /**
1350     * Writes string to file. No line length wrap or protection.
1351     *
1352     * @param file   The File to write to.
1353     * @param string The string to write.
1354     */
1355    protected void addLine(PrintWriter file, String string) {
1356        log.debug("addLine: {}", string);
1357        if (file != null) {
1358            file.println(string);
1359        }
1360    }
1361
1362    /**
1363     * Writes a string to a file. Checks for string length, and will
1364     * automatically wrap lines.
1365     *
1366     * @param file       The File to write to.
1367     * @param string     The string to write.
1368     * @param isManifest set true for manifest page orientation, false for
1369     *                   switch list orientation
1370     */
1371    protected void newLine(PrintWriter file, String string, boolean isManifest) {
1372        String[] lines = string.split(NEW_LINE);
1373        for (String line : lines) {
1374            String[] words = line.split(SPACE);
1375            StringBuffer sb = new StringBuffer();
1376            for (String word : words) {
1377                if (checkStringLength(sb.toString() + word, isManifest)) {
1378                    sb.append(word + SPACE);
1379                } else {
1380                    sb.setLength(sb.length() - 1); // remove last space added to string
1381                    addLine(file, sb.toString());
1382                    sb = new StringBuffer(word + SPACE);
1383                }
1384            }
1385            if (sb.length() > 0) {
1386                sb.setLength(sb.length() - 1); // remove last space added to string
1387            }
1388            addLine(file, sb.toString());
1389        }
1390    }
1391
1392    /**
1393     * Adds a blank line to the file.
1394     *
1395     * @param file The File to write to.
1396     */
1397    protected void newLine(PrintWriter file) {
1398        file.println(BLANK_LINE);
1399    }
1400
1401    /**
1402     * Splits a string (example-number) as long as the second part of the string
1403     * is an integer or if the first character after the hyphen is a left
1404     * parenthesis "(".
1405     *
1406     * @param name The string to split if necessary.
1407     * @return First half of the string.
1408     */
1409    public static String splitString(String name) {
1410        String[] splitname = name.split(HYPHEN);
1411        // is the hyphen followed by a number or left parenthesis?
1412        if (splitname.length > 1 && !splitname[1].startsWith("(")) {
1413            try {
1414                Integer.parseInt(splitname[1]);
1415            } catch (NumberFormatException e) {
1416                // no return full name
1417                return name.trim();
1418            }
1419        }
1420        return splitname[0].trim();
1421    }
1422
1423    /**
1424     * Splits a string if there's a hyphen followed by a left parenthesis "-(".
1425     * 
1426     * @param name the string to split
1427     * @return First half of the string.
1428     */
1429    public static String splitStringLeftParenthesis(String name) {
1430        String[] splitname = name.split(HYPHEN);
1431        if (splitname.length > 1 && splitname[1].startsWith("(")) {
1432            return splitname[0].trim();
1433        }
1434        return name.trim();
1435    }
1436
1437    // returns true if there's work at location
1438    protected boolean isThereWorkAtLocation(List<Car> carList, List<Engine> engList, RouteLocation rl) {
1439        if (carList != null) {
1440            for (Car car : carList) {
1441                if (car.getRouteLocation() == rl || car.getRouteDestination() == rl) {
1442                    return true;
1443                }
1444            }
1445        }
1446        if (engList != null) {
1447            for (Engine eng : engList) {
1448                if (eng.getRouteLocation() == rl || eng.getRouteDestination() == rl) {
1449                    return true;
1450                }
1451            }
1452        }
1453        return false;
1454    }
1455
1456    /**
1457     * returns true if the train has work at the location
1458     *
1459     * @param train    The Train.
1460     * @param location The Location.
1461     * @return true if the train has work at the location
1462     */
1463    public static boolean isThereWorkAtLocation(Train train, Location location) {
1464        if (isThereWorkAtLocation(train, location, InstanceManager.getDefault(CarManager.class).getList(train))) {
1465            return true;
1466        }
1467        if (isThereWorkAtLocation(train, location, InstanceManager.getDefault(EngineManager.class).getList(train))) {
1468            return true;
1469        }
1470        return false;
1471    }
1472
1473    private static boolean isThereWorkAtLocation(Train train, Location location, List<? extends RollingStock> list) {
1474        for (RollingStock rs : list) {
1475            if ((rs.getRouteLocation() != null &&
1476                    rs.getTrack() != null &&
1477                    rs.getRouteLocation().getSplitName()
1478                            .equals(location.getSplitName())) ||
1479                    (rs.getRouteDestination() != null &&
1480                            rs.getRouteDestination().getSplitName().equals(location.getSplitName()))) {
1481                return true;
1482            }
1483        }
1484        return false;
1485    }
1486
1487    protected void addCarsLocationUnknown(PrintWriter file, boolean isManifest) {
1488        List<Car> cars = carManager.getCarsLocationUnknown();
1489        if (cars.size() == 0) {
1490            return; // no cars to search for!
1491        }
1492        newLine(file);
1493        newLine(file, Setup.getMiaComment(), isManifest);
1494        if (Setup.isPrintHeadersEnabled()) {
1495            printHorizontalLine1(file, isManifest);
1496            newLine(file, SPACE + getHeader(Setup.getMissingCarMessageFormat(), false, false, false), isManifest);
1497            printHorizontalLine2(file, isManifest);
1498        }
1499        for (Car car : cars) {
1500            addSearchForCar(file, car, isManifest);
1501        }
1502    }
1503
1504    private void addSearchForCar(PrintWriter file, Car car, boolean isManifest) {
1505        StringBuffer buf = new StringBuffer();
1506        String[] format = Setup.getMissingCarMessageFormat();
1507        for (String attribute : format) {
1508            buf.append(getCarAttribute(car, attribute, false, false));
1509        }
1510        newLine(file, buf.toString(), isManifest);
1511    }
1512
1513    /*
1514     * Gets an engine's attribute String. Returns empty if there isn't an
1515     * attribute and not using the tabular feature. isPickup true when engine is
1516     * being picked up.
1517     */
1518    private String getEngineAttribute(Engine engine, String attribute, boolean isPickup) {
1519        if (!attribute.equals(Setup.BLANK)) {
1520            String s = SPACE + getEngineAttrib(engine, attribute, isPickup);
1521            if (Setup.isTabEnabled() || !s.isBlank()) {
1522                return s;
1523            }
1524        }
1525        return "";
1526    }
1527
1528    /*
1529     * Can not use String case statement since Setup.MODEL, etc, are not fixed
1530     * strings.
1531     */
1532    private String getEngineAttrib(Engine engine, String attribute, boolean isPickup) {
1533        if (attribute.equals(Setup.MODEL)) {
1534            return padAndTruncateIfNeeded(splitStringLeftParenthesis(engine.getModel()),
1535                    InstanceManager.getDefault(EngineModels.class).getMaxNameLength());
1536        } else if (attribute.equals(Setup.HP)) {
1537            return padAndTruncateIfNeeded(engine.getHp(), 5) +
1538                    (Setup.isPrintHeadersEnabled() ? "" : TrainManifestHeaderText.getStringHeader_Hp());
1539        } else if (attribute.equals(Setup.CONSIST)) {
1540            return padAndTruncateIfNeeded(engine.getConsistName(),
1541                    InstanceManager.getDefault(ConsistManager.class).getMaxNameLength());
1542        } else if (attribute.equals(Setup.DCC_ADDRESS)) {
1543            return padAndTruncateIfNeeded(engine.getDccAddress(),
1544                    TrainManifestHeaderText.getStringHeader_DCC_Address().length());
1545        } else if (attribute.equals(Setup.COMMENT)) {
1546            return padAndTruncateIfNeeded(engine.getComment(), engineManager.getMaxCommentLength());
1547        }
1548        return getRollingStockAttribute(engine, attribute, isPickup, false);
1549    }
1550
1551    /*
1552     * Gets a car's attribute String. Returns empty if there isn't an attribute
1553     * and not using the tabular feature. isPickup true when car is being picked
1554     * up. isLocal true when car is performing a local move.
1555     */
1556    private String getCarAttribute(Car car, String attribute, boolean isPickup, boolean isLocal) {
1557        if (!attribute.equals(Setup.BLANK)) {
1558            String s = SPACE + getCarAttrib(car, attribute, isPickup, isLocal);
1559            if (Setup.isTabEnabled() || !s.isBlank()) {
1560                return s;
1561            }
1562        }
1563        return "";
1564    }
1565
1566    private String getCarAttrib(Car car, String attribute, boolean isPickup, boolean isLocal) {
1567        if (attribute.equals(Setup.LOAD)) {
1568            return ((car.isCaboose() && !Setup.isPrintCabooseLoadEnabled()) ||
1569                    (car.isPassenger() && !Setup.isPrintPassengerLoadEnabled()))
1570                            ? padAndTruncateIfNeeded("",
1571                                    InstanceManager.getDefault(CarLoads.class).getMaxNameLength())
1572                            : padAndTruncateIfNeeded(car.getLoadName().split(HYPHEN)[0],
1573                                    InstanceManager.getDefault(CarLoads.class).getMaxNameLength());
1574        } else if (attribute.equals(Setup.LOAD_TYPE)) {
1575            return padAndTruncateIfNeeded(car.getLoadType(),
1576                    TrainManifestHeaderText.getStringHeader_Load_Type().length());
1577        } else if (attribute.equals(Setup.HAZARDOUS)) {
1578            return (car.isHazardous() ? Setup.getHazardousMsg()
1579                    : padAndTruncateIfNeeded("", Setup.getHazardousMsg().length()));
1580        } else if (attribute.equals(Setup.DROP_COMMENT)) {
1581            return padAndTruncateIfNeeded(car.getDropComment(),
1582                    InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength());
1583        } else if (attribute.equals(Setup.PICKUP_COMMENT)) {
1584            return padAndTruncateIfNeeded(car.getPickupComment(),
1585                    InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength());
1586        } else if (attribute.equals(Setup.KERNEL)) {
1587            return padAndTruncateIfNeeded(car.getKernelName(),
1588                    InstanceManager.getDefault(KernelManager.class).getMaxNameLength());
1589        } else if (attribute.equals(Setup.KERNEL_SIZE)) {
1590            if (car.isLead()) {
1591                return padAndTruncateIfNeeded(Integer.toString(car.getKernel().getSize()), 2);
1592            }
1593            return SPACE + SPACE; // assumes that kernel size is 99 or less
1594        } else if (attribute.equals(Setup.RWE)) {
1595            if (!car.getReturnWhenEmptyDestinationName().equals(Car.NONE)) {
1596                // format RWE destination and track name
1597                String rweAndTrackName = car.getSplitReturnWhenEmptyDestinationName();
1598                if (!car.getReturnWhenEmptyDestTrackName().equals(Car.NONE)) {
1599                    rweAndTrackName = rweAndTrackName + "," + SPACE + car.getSplitReturnWhenEmptyDestinationTrackName();
1600                }
1601                return Setup.isPrintHeadersEnabled()
1602                        ? padAndTruncateIfNeeded(rweAndTrackName, locationManager.getMaxLocationAndTrackNameLength())
1603                        : padAndTruncateIfNeeded(
1604                                TrainManifestHeaderText.getStringHeader_RWE() + SPACE + rweAndTrackName,
1605                                locationManager.getMaxLocationAndTrackNameLength() +
1606                                        TrainManifestHeaderText.getStringHeader_RWE().length() +
1607                                        3);
1608            }
1609            return padAndTruncateIfNeeded("", locationManager.getMaxLocationAndTrackNameLength());
1610        } else if (attribute.equals(Setup.FINAL_DEST)) {
1611            return Setup.isPrintHeadersEnabled()
1612                    ? padAndTruncateIfNeeded(car.getSplitFinalDestinationName(),
1613                            locationManager.getMaxLocationNameLength())
1614                    : padAndTruncateIfNeeded(
1615                            TrainManifestText.getStringFinalDestination() +
1616                                    SPACE +
1617                                    car.getSplitFinalDestinationName(),
1618                            locationManager.getMaxLocationNameLength() +
1619                                    TrainManifestText.getStringFinalDestination().length() +
1620                                    1);
1621        } else if (attribute.equals(Setup.FINAL_DEST_TRACK)) {
1622            // format final destination and track name
1623            String FDAndTrackName = car.getSplitFinalDestinationName();
1624            if (!car.getFinalDestinationTrackName().equals(Car.NONE)) {
1625                FDAndTrackName = FDAndTrackName + "," + SPACE + car.getSplitFinalDestinationTrackName();
1626            }
1627            return Setup.isPrintHeadersEnabled()
1628                    ? padAndTruncateIfNeeded(FDAndTrackName, locationManager.getMaxLocationAndTrackNameLength() + 2)
1629                    : padAndTruncateIfNeeded(TrainManifestText.getStringFinalDestination() + SPACE + FDAndTrackName,
1630                            locationManager.getMaxLocationAndTrackNameLength() +
1631                                    TrainManifestText.getStringFinalDestination().length() +
1632                                    3);
1633        } else if (attribute.equals(Setup.DIVISION)) {
1634            return padAndTruncateIfNeeded(car.getDivisionName(),
1635                    InstanceManager.getDefault(DivisionManager.class).getMaxDivisionNameLength());
1636        } else if (attribute.equals(Setup.BLOCKING_ORDER)) {
1637            if (car.isPassenger()) {
1638                return padAndTruncateIfNeeded(Integer.toString(car.getBlocking()), 3);
1639            }
1640            return SPACE + SPACE + SPACE; // assumes that blocking order is +/- 99
1641        } else if (attribute.equals(Setup.COMMENT)) {
1642            return padAndTruncateIfNeeded(car.getComment(), carManager.getMaxCommentLength());
1643        }
1644        return getRollingStockAttribute(car, attribute, isPickup, isLocal);
1645    }
1646
1647    private String getRollingStockAttribute(RollingStock rs, String attribute, boolean isPickup, boolean isLocal) {
1648        try {
1649            if (attribute.equals(Setup.NUMBER)) {
1650                return padAndTruncateIfNeeded(splitString(rs.getNumber()), Control.max_len_string_print_road_number);
1651            } else if (attribute.equals(Setup.ROAD)) {
1652                String road = rs.getRoadName().split(HYPHEN)[0];
1653                return padAndTruncateIfNeeded(road, InstanceManager.getDefault(CarRoads.class).getMaxNameLength());
1654            } else if (attribute.equals(Setup.TYPE)) {
1655                String type = rs.getTypeName().split(HYPHEN)[0];
1656                return padAndTruncateIfNeeded(type, InstanceManager.getDefault(CarTypes.class).getMaxNameLength());
1657            } else if (attribute.equals(Setup.LENGTH)) {
1658                return padAndTruncateIfNeeded(rs.getLength() + Setup.getLengthUnitAbv(),
1659                        InstanceManager.getDefault(CarLengths.class).getMaxNameLength());
1660            } else if (attribute.equals(Setup.WEIGHT)) {
1661                return padAndTruncateIfNeeded(Integer.toString(rs.getAdjustedWeightTons()),
1662                        Control.max_len_string_weight_name) +
1663                        (Setup.isPrintHeadersEnabled() ? "" : TrainManifestHeaderText.getStringHeader_Weight());
1664            } else if (attribute.equals(Setup.COLOR)) {
1665                return padAndTruncateIfNeeded(rs.getColor(),
1666                        InstanceManager.getDefault(CarColors.class).getMaxNameLength());
1667            } else if (((attribute.equals(Setup.LOCATION)) && (isPickup || isLocal)) ||
1668                    (attribute.equals(Setup.TRACK) && isPickup)) {
1669                return Setup.isPrintHeadersEnabled()
1670                        ? padAndTruncateIfNeeded(rs.getSplitTrackName(),
1671                                locationManager.getMaxTrackNameLength())
1672                        : padAndTruncateIfNeeded(
1673                                TrainManifestText.getStringFrom() + SPACE + rs.getSplitTrackName(),
1674                                TrainManifestText.getStringFrom().length() +
1675                                        locationManager.getMaxTrackNameLength() +
1676                                        1);
1677            } else if (attribute.equals(Setup.LOCATION) && !isPickup && !isLocal) {
1678                return Setup.isPrintHeadersEnabled()
1679                        ? padAndTruncateIfNeeded(rs.getSplitLocationName(),
1680                                locationManager.getMaxLocationNameLength())
1681                        : padAndTruncateIfNeeded(
1682                                TrainManifestText.getStringFrom() + SPACE + rs.getSplitLocationName(),
1683                                locationManager.getMaxLocationNameLength() +
1684                                        TrainManifestText.getStringFrom().length() +
1685                                        1);
1686            } else if (attribute.equals(Setup.DESTINATION) && isPickup) {
1687                if (Setup.isPrintHeadersEnabled()) {
1688                    return padAndTruncateIfNeeded(rs.getSplitDestinationName(),
1689                            locationManager.getMaxLocationNameLength());
1690                }
1691                if (Setup.isTabEnabled()) {
1692                    return padAndTruncateIfNeeded(
1693                            TrainManifestText.getStringDest() + SPACE + rs.getSplitDestinationName(),
1694                            TrainManifestText.getStringDest().length() +
1695                                    locationManager.getMaxLocationNameLength() +
1696                                    1);
1697                } else {
1698                    return TrainManifestText.getStringDestination() +
1699                            SPACE +
1700                            rs.getSplitDestinationName();
1701                }
1702            } else if ((attribute.equals(Setup.DESTINATION) || attribute.equals(Setup.TRACK)) && !isPickup) {
1703                return Setup.isPrintHeadersEnabled()
1704                        ? padAndTruncateIfNeeded(rs.getSplitDestinationTrackName(),
1705                                locationManager.getMaxTrackNameLength())
1706                        : padAndTruncateIfNeeded(
1707                                TrainManifestText.getStringTo() +
1708                                        SPACE +
1709                                        rs.getSplitDestinationTrackName(),
1710                                locationManager.getMaxTrackNameLength() +
1711                                        TrainManifestText.getStringTo().length() +
1712                                        1);
1713            } else if (attribute.equals(Setup.DEST_TRACK)) {
1714                // format destination name and destination track name
1715                String destAndTrackName =
1716                        rs.getSplitDestinationName() + "," + SPACE + rs.getSplitDestinationTrackName();
1717                return Setup.isPrintHeadersEnabled()
1718                        ? padAndTruncateIfNeeded(destAndTrackName,
1719                                locationManager.getMaxLocationAndTrackNameLength() + 2)
1720                        : padAndTruncateIfNeeded(TrainManifestText.getStringDest() + SPACE + destAndTrackName,
1721                                locationManager.getMaxLocationAndTrackNameLength() +
1722                                        TrainManifestText.getStringDest().length() +
1723                                        3);
1724            } else if (attribute.equals(Setup.OWNER)) {
1725                return padAndTruncateIfNeeded(rs.getOwnerName(),
1726                        InstanceManager.getDefault(CarOwners.class).getMaxNameLength());
1727            } else if (attribute.equals(Setup.LAST_TRAIN)) {
1728                String lastTrainName = padAndTruncateIfNeeded(rs.getLastTrainName(),
1729                        InstanceManager.getDefault(TrainManager.class).getMaxTrainNameLength());
1730                return Setup.isPrintHeadersEnabled() ? lastTrainName
1731                        : TrainManifestHeaderText.getStringHeader_Last_Train() + SPACE + lastTrainName;
1732            }
1733            // the three utility attributes that don't get printed but need to
1734              // be tabbed out
1735            else if (attribute.equals(Setup.NO_NUMBER)) {
1736                return padAndTruncateIfNeeded("",
1737                        Control.max_len_string_print_road_number - (UTILITY_CAR_COUNT_FIELD_SIZE + 1));
1738            } else if (attribute.equals(Setup.NO_ROAD)) {
1739                return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarRoads.class).getMaxNameLength());
1740            } else if (attribute.equals(Setup.NO_COLOR)) {
1741                return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarColors.class).getMaxNameLength());
1742            } // there are four truncated manifest attributes
1743            else if (attribute.equals(Setup.NO_DEST_TRACK)) {
1744                return Setup.isPrintHeadersEnabled()
1745                        ? padAndTruncateIfNeeded("", locationManager.getMaxLocationAndTrackNameLength() + 1)
1746                        : "";
1747            } else if ((attribute.equals(Setup.NO_LOCATION) && !isPickup) ||
1748                    (attribute.equals(Setup.NO_DESTINATION) && isPickup)) {
1749                return Setup.isPrintHeadersEnabled()
1750                        ? padAndTruncateIfNeeded("", locationManager.getMaxLocationNameLength())
1751                        : "";
1752            } else if (attribute.equals(Setup.NO_TRACK) ||
1753                    attribute.equals(Setup.NO_LOCATION) ||
1754                    attribute.equals(Setup.NO_DESTINATION)) {
1755                return Setup.isPrintHeadersEnabled()
1756                        ? padAndTruncateIfNeeded("", locationManager.getMaxTrackNameLength())
1757                        : "";
1758            } else if (attribute.equals(Setup.TAB)) {
1759                return createTabIfNeeded(Setup.getTab1Length() - 1);
1760            } else if (attribute.equals(Setup.TAB2)) {
1761                return createTabIfNeeded(Setup.getTab2Length() - 1);
1762            } else if (attribute.equals(Setup.TAB3)) {
1763                return createTabIfNeeded(Setup.getTab3Length() - 1);
1764            }
1765            // something isn't right!
1766            return Bundle.getMessage("ErrorPrintOptions", attribute);
1767
1768        } catch (ArrayIndexOutOfBoundsException e) {
1769            if (attribute.equals(Setup.ROAD)) {
1770                return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarRoads.class).getMaxNameLength());
1771            } else if (attribute.equals(Setup.TYPE)) {
1772                return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarTypes.class).getMaxNameLength());
1773            }
1774            // something isn't right!
1775            return Bundle.getMessage("ErrorPrintOptions", attribute);
1776        }
1777    }
1778
1779    /**
1780     * Two column header format. Left side pick ups, right side set outs
1781     *
1782     * @param file       Manifest or switch list File.
1783     * @param isManifest True if manifest, false if switch list.
1784     */
1785    public void printEngineHeader(PrintWriter file, boolean isManifest) {
1786        int lineLength = getLineLength(isManifest);
1787        printHorizontalLine(file, isManifest);
1788        if (Setup.isPrintHeadersEnabled()) {
1789            if (!Setup.getPickupEnginePrefix().isBlank() || !Setup.getDropEnginePrefix().isBlank()) {
1790                // center engine pick up and set out text
1791                String s = padAndTruncate(tabString(Setup.getPickupEnginePrefix().trim(),
1792                        lineLength / 4 - Setup.getPickupEnginePrefix().length() / 2), lineLength / 2) +
1793                        VERTICAL_LINE_CHAR +
1794                        tabString(Setup.getDropEnginePrefix(),
1795                                lineLength / 4 - Setup.getDropEnginePrefix().length() / 2);
1796                s = padAndTruncate(s, lineLength);
1797                addLine(file, s);
1798                printHorizontalLine1(file, isManifest);
1799            }
1800
1801            String s = padAndTruncate(getPickupEngineHeader(), lineLength / 2);
1802            s = padAndTruncate(s + VERTICAL_LINE_CHAR + getDropEngineHeader(), lineLength);
1803            addLine(file, s);
1804            printHorizontalLine2(file, isManifest);
1805        }
1806    }
1807
1808    public void printPickupEngineHeader(PrintWriter file, boolean isManifest) {
1809        int lineLength = getLineLength(isManifest);
1810        printHorizontalLine1(file, isManifest);
1811        String s = padAndTruncate(createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getPickupEngineHeader(),
1812                lineLength);
1813        addLine(file, s);
1814        printHorizontalLine2(file, isManifest);
1815    }
1816
1817    public void printDropEngineHeader(PrintWriter file, boolean isManifest) {
1818        int lineLength = getLineLength(isManifest);
1819        printHorizontalLine1(file, isManifest);
1820        String s = padAndTruncate(createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getDropEngineHeader(),
1821                lineLength);
1822        addLine(file, s);
1823        printHorizontalLine2(file, isManifest);
1824    }
1825
1826    /**
1827     * Prints the two column header for cars. Left side pick ups, right side set
1828     * outs.
1829     *
1830     * @param file             Manifest or Switch List File
1831     * @param isManifest       True if manifest, false if switch list.
1832     * @param isTwoColumnTrack True if two column format using track names.
1833     */
1834    public void printCarHeader(PrintWriter file, boolean isManifest, boolean isTwoColumnTrack) {
1835        int lineLength = getLineLength(isManifest);
1836        printHorizontalLine(file, isManifest);
1837        if (Setup.isPrintHeadersEnabled()) {
1838            // center pick up and set out text
1839            String s = padAndTruncate(
1840                    tabString(Setup.getPickupCarPrefix(), lineLength / 4 - Setup.getPickupCarPrefix().length() / 2),
1841                    lineLength / 2) +
1842                    VERTICAL_LINE_CHAR +
1843                    tabString(Setup.getDropCarPrefix(), lineLength / 4 - Setup.getDropCarPrefix().length() / 2);
1844            s = padAndTruncate(s, lineLength);
1845            addLine(file, s);
1846            printHorizontalLine1(file, isManifest);
1847
1848            s = padAndTruncate(getPickupCarHeader(isManifest, isTwoColumnTrack), lineLength / 2);
1849            s = padAndTruncate(s + VERTICAL_LINE_CHAR + getDropCarHeader(isManifest, isTwoColumnTrack), lineLength);
1850            addLine(file, s);
1851            printHorizontalLine2(file, isManifest);
1852        }
1853    }
1854
1855    public void printPickupCarHeader(PrintWriter file, boolean isManifest, boolean isTwoColumnTrack) {
1856        if (Setup.isPrintHeadersEnabled()) {
1857            printHorizontalLine1(file, isManifest);
1858            String s = padAndTruncate(createTabIfNeeded(Setup.getManifestPrefixLength() + 1) +
1859                    getPickupCarHeader(isManifest, isTwoColumnTrack), getLineLength(isManifest));
1860            addLine(file, s);
1861            printHorizontalLine2(file, isManifest);
1862        }
1863    }
1864
1865    public void printDropCarHeader(PrintWriter file, boolean isManifest, boolean isTwoColumnTrack) {
1866        if (!Setup.isPrintHeadersEnabled() || getDropCarHeader(isManifest, isTwoColumnTrack).isBlank()) {
1867            return;
1868        }
1869        printHorizontalLine1(file, isManifest);
1870        String s = padAndTruncate(
1871                createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getDropCarHeader(isManifest, isTwoColumnTrack),
1872                getLineLength(isManifest));
1873        addLine(file, s);
1874        printHorizontalLine2(file, isManifest);
1875    }
1876
1877    public void printLocalCarMoveHeader(PrintWriter file, boolean isManifest) {
1878        if (!Setup.isPrintHeadersEnabled()) {
1879            return;
1880        }
1881        printHorizontalLine1(file, isManifest);
1882        String s = padAndTruncate(
1883                createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getLocalMoveHeader(isManifest),
1884                getLineLength(isManifest));
1885        addLine(file, s);
1886        printHorizontalLine2(file, isManifest);
1887    }
1888
1889    public String getPickupEngineHeader() {
1890        return getHeader(Setup.getPickupEngineMessageFormat(), PICKUP, !LOCAL, ENGINE);
1891    }
1892
1893    public String getDropEngineHeader() {
1894        return getHeader(Setup.getDropEngineMessageFormat(), !PICKUP, !LOCAL, ENGINE);
1895    }
1896
1897    public String getPickupCarHeader(boolean isManifest, boolean isTwoColumnTrack) {
1898        if (isManifest && !isTwoColumnTrack) {
1899            return getHeader(Setup.getPickupManifestMessageFormat(), PICKUP, !LOCAL, !ENGINE);
1900        } else if (!isManifest && !isTwoColumnTrack) {
1901            return getHeader(Setup.getPickupSwitchListMessageFormat(), PICKUP, !LOCAL, !ENGINE);
1902        } else if (isManifest && isTwoColumnTrack) {
1903            return getHeader(Setup.getPickupTwoColumnByTrackManifestMessageFormat(), PICKUP, !LOCAL, !ENGINE);
1904        } else {
1905            return getHeader(Setup.getPickupTwoColumnByTrackSwitchListMessageFormat(), PICKUP, !LOCAL, !ENGINE);
1906        }
1907    }
1908
1909    public String getDropCarHeader(boolean isManifest, boolean isTwoColumnTrack) {
1910        if (isManifest && !isTwoColumnTrack) {
1911            return getHeader(Setup.getDropManifestMessageFormat(), !PICKUP, !LOCAL, !ENGINE);
1912        } else if (!isManifest && !isTwoColumnTrack) {
1913            return getHeader(Setup.getDropSwitchListMessageFormat(), !PICKUP, !LOCAL, !ENGINE);
1914        } else if (isManifest && isTwoColumnTrack) {
1915            return getHeader(Setup.getDropTwoColumnByTrackManifestMessageFormat(), !PICKUP, !LOCAL, !ENGINE);
1916        } else {
1917            return getHeader(Setup.getDropTwoColumnByTrackSwitchListMessageFormat(), !PICKUP, !LOCAL, !ENGINE);
1918        }
1919    }
1920
1921    public String getLocalMoveHeader(boolean isManifest) {
1922        if (isManifest) {
1923            return getHeader(Setup.getLocalManifestMessageFormat(), !PICKUP, LOCAL, !ENGINE);
1924        } else {
1925            return getHeader(Setup.getLocalSwitchListMessageFormat(), !PICKUP, LOCAL, !ENGINE);
1926        }
1927    }
1928
1929    private String getHeader(String[] format, boolean isPickup, boolean isLocal, boolean isEngine) {
1930        StringBuffer buf = new StringBuffer();
1931        for (String attribute : format) {
1932            if (attribute.equals(Setup.BLANK)) {
1933                continue;
1934            }
1935            if (attribute.equals(Setup.ROAD)) {
1936                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Road(),
1937                        InstanceManager.getDefault(CarRoads.class).getMaxNameLength()) + SPACE);
1938            } else if (attribute.equals(Setup.NUMBER) && !isEngine) {
1939                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Number(),
1940                        Control.max_len_string_print_road_number) + SPACE);
1941            } else if (attribute.equals(Setup.NUMBER) && isEngine) {
1942                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_EngineNumber(),
1943                        Control.max_len_string_print_road_number) + SPACE);
1944            } else if (attribute.equals(Setup.TYPE)) {
1945                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Type(),
1946                        InstanceManager.getDefault(CarTypes.class).getMaxNameLength()) + SPACE);
1947            } else if (attribute.equals(Setup.MODEL)) {
1948                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Model(),
1949                        InstanceManager.getDefault(EngineModels.class).getMaxNameLength()) + SPACE);
1950            } else if (attribute.equals(Setup.HP)) {
1951                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Hp(),
1952                        5) + SPACE);
1953            } else if (attribute.equals(Setup.CONSIST)) {
1954                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Consist(),
1955                        InstanceManager.getDefault(ConsistManager.class).getMaxNameLength()) + SPACE);
1956            } else if (attribute.equals(Setup.DCC_ADDRESS)) {
1957                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_DCC_Address(),
1958                        TrainManifestHeaderText.getStringHeader_DCC_Address().length()) + SPACE);
1959            } else if (attribute.equals(Setup.KERNEL)) {
1960                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Kernel(),
1961                        InstanceManager.getDefault(KernelManager.class).getMaxNameLength()) + SPACE);
1962            } else if (attribute.equals(Setup.KERNEL_SIZE)) {
1963                buf.append("   "); // assume kernel size is 99 or less
1964            } else if (attribute.equals(Setup.LOAD)) {
1965                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Load(),
1966                        InstanceManager.getDefault(CarLoads.class).getMaxNameLength()) + SPACE);
1967            } else if (attribute.equals(Setup.LOAD_TYPE)) {
1968                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Load_Type(),
1969                        TrainManifestHeaderText.getStringHeader_Load_Type().length()) + SPACE);
1970            } else if (attribute.equals(Setup.COLOR)) {
1971                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Color(),
1972                        InstanceManager.getDefault(CarColors.class).getMaxNameLength()) + SPACE);
1973            } else if (attribute.equals(Setup.OWNER)) {
1974                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Owner(),
1975                        InstanceManager.getDefault(CarOwners.class).getMaxNameLength()) + SPACE);
1976            } else if (attribute.equals(Setup.LENGTH)) {
1977                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Length(),
1978                        InstanceManager.getDefault(CarLengths.class).getMaxNameLength()) + SPACE);
1979            } else if (attribute.equals(Setup.WEIGHT)) {
1980                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Weight(),
1981                        Control.max_len_string_weight_name) + SPACE);
1982            } else if (attribute.equals(Setup.TRACK)) {
1983                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Track(),
1984                        locationManager.getMaxTrackNameLength()) + SPACE);
1985            } else if (attribute.equals(Setup.LOCATION) && (isPickup || isLocal)) {
1986                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Location(),
1987                        locationManager.getMaxTrackNameLength()) + SPACE);
1988            } else if (attribute.equals(Setup.LOCATION) && !isPickup) {
1989                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Location(),
1990                        locationManager.getMaxLocationNameLength()) + SPACE);
1991            } else if (attribute.equals(Setup.DESTINATION) && !isPickup) {
1992                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Destination(),
1993                        locationManager.getMaxTrackNameLength()) + SPACE);
1994            } else if (attribute.equals(Setup.DESTINATION) && isPickup) {
1995                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Destination(),
1996                        locationManager.getMaxLocationNameLength()) + SPACE);
1997            } else if (attribute.equals(Setup.DEST_TRACK)) {
1998                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Dest_Track(),
1999                        locationManager.getMaxLocationAndTrackNameLength() + 2) + SPACE);
2000            } else if (attribute.equals(Setup.FINAL_DEST)) {
2001                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Final_Dest(),
2002                        locationManager.getMaxLocationNameLength()) + SPACE);
2003            } else if (attribute.equals(Setup.FINAL_DEST_TRACK)) {
2004                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Final_Dest_Track(),
2005                        locationManager.getMaxLocationAndTrackNameLength() + 2) + SPACE);
2006            } else if (attribute.equals(Setup.HAZARDOUS)) {
2007                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Hazardous(),
2008                        Setup.getHazardousMsg().length()) + SPACE);
2009            } else if (attribute.equals(Setup.RWE)) {
2010                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_RWE(),
2011                        locationManager.getMaxLocationAndTrackNameLength()) + SPACE);
2012            } else if (attribute.equals(Setup.COMMENT)) {
2013                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Comment(),
2014                        isEngine ? engineManager.getMaxCommentLength() : carManager.getMaxCommentLength()) + SPACE);
2015            } else if (attribute.equals(Setup.DROP_COMMENT)) {
2016                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Drop_Comment(),
2017                        InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength()) + SPACE);
2018            } else if (attribute.equals(Setup.PICKUP_COMMENT)) {
2019                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Pickup_Comment(),
2020                        InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength()) + SPACE);
2021            } else if (attribute.equals(Setup.DIVISION)) {
2022                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Division(),
2023                        InstanceManager.getDefault(DivisionManager.class).getMaxDivisionNameLength()) + SPACE);
2024            } else if (attribute.equals(Setup.BLOCKING_ORDER)) {
2025                buf.append("    "); // assume blocking order +/- 99
2026            } else if (attribute.equals(Setup.LAST_TRAIN)) {
2027                buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Last_Train(),
2028                        InstanceManager.getDefault(TrainManager.class).getMaxTrainNameLength()) + SPACE);
2029            } else if (attribute.equals(Setup.TAB)) {
2030                buf.append(createTabIfNeeded(Setup.getTab1Length()));
2031            } else if (attribute.equals(Setup.TAB2)) {
2032                buf.append(createTabIfNeeded(Setup.getTab2Length()));
2033            } else if (attribute.equals(Setup.TAB3)) {
2034                buf.append(createTabIfNeeded(Setup.getTab3Length()));
2035            } else {
2036                buf.append(attribute + SPACE);
2037            }
2038        }
2039        return buf.toString().stripTrailing();
2040    }
2041
2042    protected void printTrackNameHeader(PrintWriter file, String trackName, boolean isManifest) {
2043        printHorizontalLine(file, isManifest);
2044        int lineLength = getLineLength(isManifest);
2045        String s = padAndTruncate(tabString(trackName.trim(), lineLength / 4 - trackName.trim().length() / 2),
2046                lineLength / 2) +
2047                VERTICAL_LINE_CHAR +
2048                tabString(trackName.trim(), lineLength / 4 - trackName.trim().length() / 2);
2049        s = padAndTruncate(s, lineLength);
2050        addLine(file, s);
2051        if (Setup.isPrintHeaderLine3Enabled()) {
2052            printHorizontalLine(file, isManifest);
2053        }
2054    }
2055
2056    public void printHorizontalLine1(PrintWriter file, boolean isManifest) {
2057        if (Setup.isPrintHeaderLine1Enabled()) {
2058            printHorizontalLine(file, isManifest);
2059        }
2060    }
2061
2062    public void printHorizontalLine2(PrintWriter file, boolean isManifest) {
2063        if (Setup.isPrintHeaderLine2Enabled()) {
2064            printHorizontalLine(file, isManifest);
2065        }
2066    }
2067
2068    public void printHorizontalLine3(PrintWriter file, boolean isManifest) {
2069        if (Setup.isPrintHeadersEnabled() && Setup.isPrintHeaderLine3Enabled() ||
2070                !Setup.getManifestFormat().equals(Setup.STANDARD_FORMAT)) {
2071            printHorizontalLine(file, isManifest);
2072        }
2073    }
2074
2075    /**
2076     * Prints a line across the entire page.
2077     *
2078     * @param file       The File to print to.
2079     * @param isManifest True if manifest, false if switch list.
2080     */
2081    public void printHorizontalLine(PrintWriter file, boolean isManifest) {
2082        printHorizontalLine(file, 0, getLineLength(isManifest));
2083    }
2084
2085    public void printHorizontalLine(PrintWriter file, int start, int end) {
2086        StringBuffer sb = new StringBuffer();
2087        while (start-- > 0) {
2088            sb.append(SPACE);
2089        }
2090        while (end-- > 0) {
2091            sb.append(HORIZONTAL_LINE_CHAR);
2092        }
2093        addLine(file, sb.toString());
2094    }
2095
2096    public static String getISO8601Date(boolean isModelYear) {
2097        Calendar calendar = Calendar.getInstance();
2098        // use the JMRI Timebase (which may be a fast clock).
2099        calendar.setTime(jmri.InstanceManager.getDefault(jmri.Timebase.class).getTime());
2100        if (isModelYear && !Setup.getYearModeled().isEmpty()) {
2101            try {
2102                calendar.set(Calendar.YEAR, Integer.parseInt(Setup.getYearModeled().trim()));
2103            } catch (NumberFormatException e) {
2104                return Setup.getYearModeled();
2105            }
2106        }
2107        return (new StdDateFormat()).format(calendar.getTime());
2108    }
2109
2110    public static String getDate(Date date) {
2111        SimpleDateFormat format = new SimpleDateFormat("M/dd/yyyy HH:mm"); // NOI18N
2112        if (Setup.is12hrFormatEnabled()) {
2113            format = new SimpleDateFormat("M/dd/yyyy hh:mm a"); // NOI18N
2114        }
2115        return format.format(date);
2116    }
2117
2118    public static String getDate(boolean isModelYear) {
2119        Calendar calendar = Calendar.getInstance();
2120        // use the JMRI Timebase (which may be a fast clock).
2121        calendar.setTime(jmri.InstanceManager.getDefault(jmri.Timebase.class).getTime());
2122        if (isModelYear && !Setup.getYearModeled().equals(Setup.NONE)) {
2123            try {
2124                calendar.set(Calendar.YEAR, Integer.parseInt(Setup.getYearModeled().trim()));
2125            } catch (NumberFormatException e) {
2126                return Setup.getYearModeled();
2127            }
2128        }
2129        return TrainCommon.getDate(calendar.getTime());
2130    }
2131
2132    public static Date convertStringToDate(String date) {
2133        if (!date.isBlank()) {
2134            // create a date object from the string.
2135            try {
2136                // try MM/dd/yyyy HH:mm:ss.
2137                SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss"); // NOI18N
2138                return formatter.parse(date);
2139            } catch (java.text.ParseException pe1) {
2140                // try the old 12 hour format (no seconds).
2141                try {
2142                    SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy hh:mmaa"); // NOI18N
2143                    return formatter.parse(date);
2144                } catch (java.text.ParseException pe2) {
2145                    try {
2146                        // try 24hour clock.
2147                        SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy HH:mm"); // NOI18N
2148                        return formatter.parse(date);
2149                    } catch (java.text.ParseException pe3) {
2150                        log.debug("Not able to parse date: {}", date);
2151                    }
2152                }
2153            }
2154        }
2155        return null; // there was no date specified.
2156    }
2157
2158    /*
2159     * Converts String time DAYS:HH:MM and DAYS:HH:MM AM/PM to minutes from
2160     * midnight. Note that the string time could be blank, and in that case
2161     * returns 0 minutes. 
2162     */
2163    protected int convertStringTime(String time) {
2164        int minutes = 0;
2165        boolean hrFormat = false;
2166        String[] splitTimePM = time.split(SPACE);
2167        if (splitTimePM.length > 1) {
2168            hrFormat = true;
2169            if (splitTimePM[1].equals(Bundle.getMessage("PM"))) {
2170                minutes = 12 * 60;
2171            }
2172        }
2173        String[] splitTime = splitTimePM[0].split(":");
2174
2175        if (splitTime.length > 2) {
2176            // days:hrs:minutes
2177            if (hrFormat && splitTime[1].equals("12")) {
2178                splitTime[1] = "00";
2179            }
2180            minutes += 24 * 60 * Integer.parseInt(splitTime[0]);
2181            minutes += 60 * Integer.parseInt(splitTime[1]);
2182            minutes += Integer.parseInt(splitTime[2]);
2183        } else if (splitTime.length  == 2){
2184            // hrs:minutes
2185            if (hrFormat && splitTime[0].equals("12")) {
2186                splitTime[0] = "00";
2187            }
2188            minutes += 60 * Integer.parseInt(splitTime[0]);
2189            minutes += Integer.parseInt(splitTime[1]);
2190        }
2191        log.debug("convert time {} to minutes {}", time, minutes);
2192        return minutes;
2193    }
2194
2195    /**
2196     * Pads out a string by adding spaces to the end of the string, and will
2197     * remove characters from the end of the string if the string exceeds the
2198     * field size.
2199     *
2200     * @param s         The string to pad.
2201     * @param fieldSize The maximum length of the string.
2202     * @return A String the specified length
2203     */
2204    public static String padAndTruncateIfNeeded(String s, int fieldSize) {
2205        if (Setup.isTabEnabled()) {
2206            return padAndTruncate(s, fieldSize);
2207        }
2208        return s;
2209    }
2210
2211    public static String padAndTruncate(String s, int fieldSize) {
2212        s = padString(s, fieldSize);
2213        if (s.length() > fieldSize) {
2214            s = s.substring(0, fieldSize);
2215        }
2216        return s;
2217    }
2218
2219    /**
2220     * Adjusts string to be a certain number of characters by adding spaces to
2221     * the end of the string.
2222     *
2223     * @param s         The string to pad
2224     * @param fieldSize The fixed length of the string.
2225     * @return A String the specified length
2226     */
2227    public static String padString(String s, int fieldSize) {
2228        StringBuffer buf = new StringBuffer(s);
2229        while (buf.length() < fieldSize) {
2230            buf.append(SPACE);
2231        }
2232        return buf.toString();
2233    }
2234
2235    /**
2236     * Creates a String of spaces to create a tab for text. Tabs must be
2237     * enabled. Setup.isTabEnabled()
2238     * 
2239     * @param tabSize the length of tab
2240     * @return tab
2241     */
2242    public static String createTabIfNeeded(int tabSize) {
2243        if (Setup.isTabEnabled()) {
2244            return tabString("", tabSize);
2245        }
2246        return "";
2247    }
2248
2249    protected static String tabString(String s, int tabSize) {
2250        StringBuffer buf = new StringBuffer();
2251        // TODO this doesn't consider the length of s string.
2252        while (buf.length() < tabSize) {
2253            buf.append(SPACE);
2254        }
2255        buf.append(s);
2256        return buf.toString();
2257    }
2258
2259    /**
2260     * Returns the line length for manifest or switch list printout. Always an
2261     * even number.
2262     * 
2263     * @param isManifest True if manifest.
2264     * @return line length for manifest or switch list.
2265     */
2266    public static int getLineLength(boolean isManifest) {
2267        return getLineLength(isManifest ? Setup.getManifestOrientation() : Setup.getSwitchListOrientation(),
2268                Setup.getFontName(), Font.PLAIN, Setup.getManifestFontSize());
2269    }
2270
2271    public static int getManifestHeaderLineLength() {
2272        return getLineLength(Setup.getManifestOrientation(), "SansSerif", Font.ITALIC, Setup.getManifestFontSize());
2273    }
2274
2275    private static int getLineLength(String orientation, String fontName, int fontStyle, int fontSize) {
2276        Font font = new Font(fontName, fontStyle, fontSize); // NOI18N
2277        JLabel label = new JLabel();
2278        FontMetrics metrics = label.getFontMetrics(font);
2279        int charwidth = metrics.charWidth('m');
2280        if (charwidth == 0) {
2281            log.error("Line length charater width equal to zero. font size: {}, fontName: {}", fontSize, fontName);
2282            charwidth = fontSize / 2; // create a reasonable character width
2283        }
2284        // compute lines and columns within margins
2285        int charLength = getPageSize(orientation).width / charwidth;
2286        if (charLength % 2 != 0) {
2287            charLength--; // make it even
2288        }
2289        return charLength;
2290    }
2291
2292    private boolean checkStringLength(String string, boolean isManifest) {
2293        return checkStringLength(string, isManifest ? Setup.getManifestOrientation() : Setup.getSwitchListOrientation(),
2294                Setup.getFontName(), Setup.getManifestFontSize());
2295    }
2296
2297    /**
2298     * Checks to see if the string fits on the page.
2299     *
2300     * @return false if string length is longer than page width.
2301     */
2302    private boolean checkStringLength(String string, String orientation, String fontName, int fontSize) {
2303        // ignore text color controls when determining line length
2304        if (string.startsWith(TEXT_COLOR_START) && string.contains(TEXT_COLOR_DONE)) {
2305            string = string.substring(string.indexOf(TEXT_COLOR_DONE) + 2);
2306        }
2307        if (string.contains(TEXT_COLOR_END)) {
2308            string = string.substring(0, string.indexOf(TEXT_COLOR_END));
2309        }
2310        Font font = new Font(fontName, Font.PLAIN, fontSize); // NOI18N
2311        JLabel label = new JLabel();
2312        FontMetrics metrics = label.getFontMetrics(font);
2313        int stringWidth = metrics.stringWidth(string);
2314        return stringWidth <= getPageSize(orientation).width;
2315    }
2316
2317    protected static final Dimension PAPER_MARGINS = new Dimension(84, 72);
2318
2319    protected static Dimension getPageSize(String orientation) {
2320        // page size has been adjusted to account for margins of .5
2321        // Dimension(84, 72)
2322        Dimension pagesize = new Dimension(523, 720); // Portrait 8.5 x 11
2323        // landscape has .65 margins
2324        if (orientation.equals(Setup.LANDSCAPE)) {
2325            pagesize = new Dimension(702, 523); // 11 x 8.5
2326        }
2327        if (orientation.equals(Setup.HALFPAGE)) {
2328            pagesize = new Dimension(261, 720); // 4.25 x 11
2329        }
2330        if (orientation.equals(Setup.HANDHELD)) {
2331            pagesize = new Dimension(206, 720); // 3.25 x 11
2332        }
2333        return pagesize;
2334    }
2335
2336    /**
2337     * Produces a string using commas and spaces between the strings provided in
2338     * the array. Does not check for embedded commas in the string array.
2339     *
2340     * @param array The string array to be formated.
2341     * @return formated string using commas and spaces
2342     */
2343    public static String formatStringToCommaSeparated(String[] array) {
2344        StringBuffer sbuf = new StringBuffer("");
2345        for (String s : array) {
2346            if (s != null) {
2347                sbuf = sbuf.append(s + "," + SPACE);
2348            }
2349        }
2350        if (sbuf.length() > 2) {
2351            sbuf.setLength(sbuf.length() - 2); // remove trailing separators
2352        }
2353        return sbuf.toString();
2354    }
2355
2356    private void addLine(PrintWriter file, StringBuffer buf, Color color) {
2357        String s = buf.toString();
2358        if (!s.isBlank()) {
2359            addLine(file, formatColorString(s, color));
2360        }
2361    }
2362
2363    /**
2364     * Adds HTML like color text control characters around a string. Note that
2365     * black is the standard text color, and if black is requested no control
2366     * characters are added.
2367     * 
2368     * @param text  the text to be modified
2369     * @param color the color the text is to be printed
2370     * @return formated text with color modifiers
2371     */
2372    public static String formatColorString(String text, Color color) {
2373        String s = text;
2374        if (!color.equals(Color.black)) {
2375            s = TEXT_COLOR_START + ColorUtil.colorToColorName(color) + TEXT_COLOR_DONE + text + TEXT_COLOR_END;
2376        }
2377        return s;
2378    }
2379
2380    /**
2381     * Removes the color text control characters around the desired string
2382     * 
2383     * @param string the string with control characters
2384     * @return pure text
2385     */
2386    public static String getTextColorString(String string) {
2387        String text = string;
2388        if (string.contains(TEXT_COLOR_START)) {
2389            text = string.substring(0, string.indexOf(TEXT_COLOR_START)) +
2390                    string.substring(string.indexOf(TEXT_COLOR_DONE) + 2);
2391        }
2392        if (text.contains(TEXT_COLOR_END)) {
2393            text = text.substring(0, text.indexOf(TEXT_COLOR_END)) +
2394                    string.substring(string.indexOf(TEXT_COLOR_END) + TEXT_COLOR_END.length());
2395        }
2396        return text;
2397    }
2398
2399    public static Color getTextColor(String string) {
2400        Color color = Color.black;
2401        if (string.contains(TEXT_COLOR_START)) {
2402            String c = string.substring(string.indexOf(TEXT_COLOR_START) + TEXT_COLOR_START.length());
2403            c = c.substring(0, c.indexOf("\""));
2404            color = ColorUtil.stringToColor(c);
2405        }
2406        return color;
2407    }
2408
2409    public static String getTextColorName(String string) {
2410        return ColorUtil.colorToColorName(getTextColor(string));
2411    }
2412
2413    private static final Logger log = LoggerFactory.getLogger(TrainCommon.class);
2414}