니로의 마음 편한 공간

1
/**
2
 * 입력 스트림이 닫혔을 때(Ctrl+D, Ctrl+Z 등) 프로그램을 안전하게 종료하기 위한 예외.
3
 */
4
public class InputClosedException extends RuntimeException
5
{
6
    private static final long serialVersionUID = 1L;
7

8
    public InputClosedException()
9
    {
10
        super("입력 스트림이 종료되었습니다.");
11
    }
12
}

1
import java.util.List;
2

3
/**
4
 * 콘솔 출력 전용 유틸리티. (제목, 안내/오류 메시지, 표 출력)
5
 * <p>
6
 * 한글은 콘솔에서 영문보다 2배 넓게 표시되므로, 표를 정렬할 때 글자 수가 아닌 "표시 폭"을 기준으로 맞춘다.
7
 */
8
public class ConsoleUI
9
{
10
    public static final int WIDTH = 64;
11

12
    private ConsoleUI()
13
    {
14
    }
15

16
    public static void title(String text)
17
    {
18
        System.out.println();
19
        System.out.println(repeat('=', WIDTH));
20
        System.out.println(center(text, WIDTH));
21
        System.out.println(repeat('=', WIDTH));
22
    }
23

24
    public static void section(String text)
25
    {
26
        System.out.println();
27
        String head = "---- " + text + " ";
28
        System.out.println(head + repeat('-', Math.max(4, WIDTH - displayWidth(head))));
29
    }
30

31
    public static void success(String message)
32
    {
33
        System.out.println("  [완료] " + message);
34
    }
35

36
    public static void error(String message)
37
    {
38
        System.out.println("  [오류] " + message);
39
    }
40

41
    public static void info(String message)
42
    {
43
        System.out.println("  [안내] " + message);
44
    }
45

46
    /** 헤더와 행 데이터를 받아 테두리가 있는 표로 출력한다. */
47
    public static void printTable(String[] headers, List<String[]> rows)
48
    {
49
        int[] widths = new int[headers.length];
50
        for (int i = 0; i < headers.length; i++)
51
        {
52
            widths[i] = displayWidth(headers[i]);
53
        }
54
        for (String[] row : rows)
55
        {
56
            for (int i = 0; i < headers.length; i++)
57
            {
58
                widths[i] = Math.max(widths[i], displayWidth(row[i]));
59
            }
60
        }
61

62
        String border = buildBorder(widths);
63
        System.out.println(border);
64
        System.out.println(buildRow(headers, widths));
65
        System.out.println(border);
66
        for (String[] row : rows)
67
        {
68
            System.out.println(buildRow(row, widths));
69
        }
70
        System.out.println(border);
71
    }
72

73
    private static String buildBorder(int[] widths)
74
    {
75
        StringBuilder sb = new StringBuilder("  +");
76
        for (int w : widths)
77
        {
78
            sb.append(repeat('-', w + 2)).append('+');
79
        }
80
        return sb.toString();
81
    }
82

83
    private static String buildRow(String[] cells, int[] widths)
84
    {
85
        StringBuilder sb = new StringBuilder("  |");
86
        for (int i = 0; i < widths.length; i++)
87
        {
88
            sb.append(' ').append(pad(cells[i], widths[i])).append(" |");
89
        }
90
        return sb.toString();
91
    }
92

93
    /** 문자열의 콘솔 표시 폭 (한글/전각 문자는 2칸) */
94
    public static int displayWidth(String s)
95
    {
96
        int width = 0;
97
        for (int i = 0; i < s.length(); i++)
98
        {
99
            width += isWide(s.charAt(i)) ? 2 : 1;
100
        }
101
        return width;
102
    }
103

104
    private static boolean isWide(char c)
105
    {
106
        return (c >= 0x1100 && c <= 0x115F)     // 한글 자모
107
                || (c >= 0x2E80 && c <= 0xA4CF) // CJK
108
                || (c >= 0xAC00 && c <= 0xD7A3) // 한글 음절
109
                || (c >= 0xF900 && c <= 0xFAFF)
110
                || (c >= 0xFE30 && c <= 0xFE4F)
111
                || (c >= 0xFF00 && c <= 0xFF60) // 전각 문자
112
                || (c >= 0xFFE0 && c <= 0xFFE6);
113
    }
114

115
    /** 표시 폭 기준으로 오른쪽을 공백으로 채운다. */
116
    public static String pad(String s, int width)
117
    {
118
        StringBuilder sb = new StringBuilder(s);
119
        for (int w = displayWidth(s); w < width; w++)
120
        {
121
            sb.append(' ');
122
        }
123
        return sb.toString();
124
    }
125

126
    public static String center(String s, int width)
127
    {
128
        int left = Math.max(0, (width - displayWidth(s)) / 2);
129
        return repeat(' ', left) + s;
130
    }
131

132
    public static String repeat(char c, int n)
133
    {
134
        StringBuilder sb = new StringBuilder();
135
        for (int i = 0; i < n; i++)
136
        {
137
            sb.append(c);
138
        }
139
        return sb.toString();
140
    }
141
}

1
import java.util.NoSuchElementException;
2
import java.util.Scanner;
3

4
/**
5
 * 콘솔 입력 전용 유틸리티.
6
 * <p>
7
 * - 프로그램 전체가 하나의 Scanner 를 공유한다. (System.in 에 Scanner 를 여러 개 만들면 입력이 유실될 수 있음)
8
 * - 모든 입력을 한 줄 단위(nextLine)로 읽어서, nextInt() 뒤에 남는 개행 문제를 없앤다.
9
 * - 숫자 입력에 문자가 들어오거나 범위를 벗어나면 예외로 죽지 않고 다시 입력받는다.
10
 */
11
public class ConsoleInput
12
{
13
    private static final Scanner SCANNER = new Scanner(System.in);
14

15
    private ConsoleInput()
16
    {
17
    }
18

19
    /** 한 줄을 읽어 앞뒤 공백을 제거해 돌려준다. */
20
    public static String readLine(String prompt)
21
    {
22
        System.out.print("  " + prompt);
23
        try
24
        {
25
            return SCANNER.nextLine().trim();
26
        } catch (NoSuchElementException | IllegalStateException e)
27
        {
28
            throw new InputClosedException();
29
        }
30
    }
31

32
    /** min ~ max 범위의 정수를 입력받는다. 올바른 값이 들어올 때까지 반복한다. */
33
    public static int readInt(String prompt, int min, int max)
34
    {
35
        while (true)
36
        {
37
            String line = readLine(prompt);
38
            if (line.isEmpty())
39
            {
40
                ConsoleUI.error("값이 입력되지 않았습니다. " + min + " ~ " + max + " 사이의 숫자를 입력해주세요.");
41
                continue;
42
            }
43
            try
44
            {
45
                int value = Integer.parseInt(line);
46
                if (value < min || value > max)
47
                {
48
                    ConsoleUI.error(value + "은(는) 범위를 벗어났습니다. " + min + " ~ " + max + " 사이의 숫자를 입력해주세요.");
49
                    continue;
50
                }
51
                return value;
52
            } catch (NumberFormatException e)
53
            {
54
                ConsoleUI.error("'" + line + "'은(는) 숫자가 아닙니다. " + min + " ~ " + max + " 사이의 숫자를 입력해주세요.");
55
            }
56
        }
57
    }
58

59
    /** y/n 질문. 한글 자판 상태에서 누른 ㅛ/ㅜ 도 허용한다. */
60
    public static boolean confirm(String prompt)
61
    {
62
        while (true)
63
        {
64
            String line = readLine(prompt + " (y/n) : ").toLowerCase();
65
            if (line.equals("y") || line.equals("yes") || line.equals("ㅛ"))
66
            {
67
                return true;
68
            }
69
            if (line.equals("n") || line.equals("no") || line.equals("ㅜ"))
70
            {
71
                return false;
72
            }
73
            ConsoleUI.error("y(예) 또는 n(아니오)로 입력해주세요.");
74
        }
75
    }
76
}

1
public class Screen
2
{
3
    private String name;
4
    private int rowNum;
5
    private int seatNum;
6

7
    public Screen(String name, int rowNum, int seatNum)
8
    {
9
        this.name = name;
10
        this.rowNum = rowNum;
11
        this.seatNum = seatNum;
12
    }
13

14
    /** 총 좌석 수 */
15
    public int getTotalSeats()
16
    {
17
        return rowNum * seatNum;
18
    }
19

20
    /** 예) 5열 x 10석 */
21
    public String getLayoutText()
22
    {
23
        return rowNum + "열 x " + seatNum + "석";
24
    }
25

26
    @Override
27
    public String toString()
28
    {
29
        return "Screen [name=" + name + ", rowNum=" + rowNum + ", seatNum=" + seatNum + "]";
30
    }
31

32
    public String getName()
33
    {
34
        return name;
35
    }
36

37
    public void setName(String name)
38
    {
39
        this.name = name;
40
    }
41

42
    public int getRowNum()
43
    {
44
        return rowNum;
45
    }
46

47
    public void setRowNum(int rowNum)
48
    {
49
        this.rowNum = rowNum;
50
    }
51

52
    public int getSeatNum()
53
    {
54
        return seatNum;
55
    }
56

57
    public void setSeatNum(int seatNum)
58
    {
59
        this.seatNum = seatNum;
60
    }
61
}

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public class ScreenManager
5
{
6
    public static final int MAX_ROWS = 20;
7
    public static final int MAX_SEATS_PER_ROW = 20;
8
    private static final int MAX_NAME_WIDTH = 20;
9

10
    private Screen[] screens;
11
    private int maxCount;
12
    private int count;
13
    private TimetableManager tm; // 상영일정이 걸린 상영관은 삭제하지 못하도록 확인용
14

15
    public ScreenManager(int maxCount)
16
    {
17
        this.maxCount = maxCount;
18
        this.screens = new Screen[maxCount];
19
        count = 0;
20
    }
21

22
    public void setTimetableManager(TimetableManager tm)
23
    {
24
        this.tm = tm;
25
    }
26

27
    public void add()
28
    {
29
        ConsoleUI.section("상영관 등록");
30
        if (count == maxCount)
31
        {
32
            ConsoleUI.error("상영관을 더 이상 등록할 수 없습니다. (최대 " + maxCount + "개)");
33
            ConsoleUI.info("사용하지 않는 상영관을 삭제한 뒤 다시 시도해주세요.");
34
            return;
35
        }
36

37
        String name;
38
        while (true)
39
        {
40
            name = ConsoleInput.readLine("상영관 이름 (예: 1관, 빈 입력 시 취소) : ");
41
            if (name.isEmpty())
42
            {
43
                ConsoleUI.info("상영관 등록을 취소했습니다.");
44
                return;
45
            }
46
            if (ConsoleUI.displayWidth(name) > MAX_NAME_WIDTH)
47
            {
48
                ConsoleUI.error("이름이 너무 깁니다. (한글 10자 / 영문 20자 이내)");
49
                continue;
50
            }
51
            if (findByName(name) != null)
52
            {
53
                ConsoleUI.error("'" + name + "'은(는) 이미 등록된 상영관입니다. 다른 이름을 입력해주세요.");
54
                continue;
55
            }
56
            break;
57
        }
58
        int rowNum = ConsoleInput.readInt("좌석 열 수 (1~" + MAX_ROWS + ") : ", 1, MAX_ROWS);
59
        int seatNum = ConsoleInput.readInt("한 열의 좌석 수 (1~" + MAX_SEATS_PER_ROW + ") : ", 1, MAX_SEATS_PER_ROW);
60

61
        Screen screen = new Screen(name, rowNum, seatNum);
62
        addScreen(screen);
63
        ConsoleUI.success("'" + name + "' 상영관이 등록되었습니다. (" + screen.getLayoutText() + ", 총 "
64
                + screen.getTotalSeats() + "석) [" + count + "/" + maxCount + "]");
65
    }
66

67
    /** 입력 없이 상영관을 추가한다. (샘플 데이터용) */
68
    public boolean addScreen(Screen screen)
69
    {
70
        if (count == maxCount || findByName(screen.getName()) != null)
71
        {
72
            return false;
73
        }
74
        screens[count] = screen;
75
        count++;
76
        return true;
77
    }
78

79
    public void list()
80
    {
81
        ConsoleUI.section("상영관 목록 (" + count + "/" + maxCount + ")");
82
        if (count == 0)
83
        {
84
            ConsoleUI.info("등록된 상영관이 없습니다. 1번(등록)으로 상영관을 추가해보세요.");
85
            return;
86
        }
87
        printScreenTable();
88
    }
89

90
    private void printScreenTable()
91
    {
92
        List<String[]> rows = new ArrayList<String[]>();
93
        for (int i = 0; i < count; i++)
94
        {
95
            MovieTimetable mt = (tm == null) ? null : tm.findByScreen(screens[i]);
96
            rows.add(new String[] {
97
                    String.valueOf(i + 1),
98
                    screens[i].getName(),
99
                    screens[i].getLayoutText(),
100
                    screens[i].getTotalSeats() + "석",
101
                    mt == null ? "-" : mt.getMovie().getTitle()
102
            });
103
        }
104
        ConsoleUI.printTable(new String[] {"번호", "상영관", "좌석 배치", "총 좌석", "상영 중인 영화"}, rows);
105
    }
106

107
    public void remove()
108
    {
109
        ConsoleUI.section("상영관 삭제");
110
        if (count == 0)
111
        {
112
            ConsoleUI.info("삭제할 상영관이 없습니다.");
113
            return;
114
        }
115
        printScreenTable();
116
        int select = ConsoleInput.readInt("삭제할 상영관 번호 (0. 취소) >> ", 0, count);
117
        if (select == 0)
118
        {
119
            ConsoleUI.info("삭제를 취소했습니다.");
120
            return;
121
        }
122

123
        int index = select - 1;
124
        Screen target = screens[index];
125
        if (tm != null && tm.findByScreen(target) != null)
126
        {
127
            ConsoleUI.error("'" + target.getName() + "'에는 상영일정이 등록되어 있어 삭제할 수 없습니다.");
128
            ConsoleUI.info("상영일정 관리에서 해당 일정을 먼저 삭제해주세요.");
129
            return;
130
        }
131
        if (!ConsoleInput.confirm("'" + target.getName() + "' 상영관을 삭제할까요?"))
132
        {
133
            ConsoleUI.info("삭제를 취소했습니다.");
134
            return;
135
        }
136

137
        // 뒤의 원소를 한 칸씩 당긴다. (j + 1 이 배열 범위를 넘지 않도록 count - 1 까지만)
138
        for (int j = index; j < count - 1; j++)
139
        {
140
            screens[j] = screens[j + 1];
141
        }
142
        screens[count - 1] = null;
143
        count--;
144
        ConsoleUI.success("'" + target.getName() + "' 상영관이 삭제되었습니다.");
145
    }
146

147
    public void screenManagerMain()
148
    {
149
        while (true)
150
        {
151
            ConsoleUI.title("상영관 관리  (등록 " + count + "/" + maxCount + ")");
152
            System.out.println("  1. 상영관 등록");
153
            System.out.println("  2. 상영관 목록");
154
            System.out.println("  3. 상영관 삭제");
155
            System.out.println("  0. 메인 메뉴로");
156
            int input = ConsoleInput.readInt("메뉴 선택 >> ", 0, 3);
157
            switch (input)
158
            {
159
                case 1:
160
                    add();
161
                    break;
162
                case 2:
163
                    list();
164
                    break;
165
                case 3:
166
                    remove();
167
                    break;
168
                case 0:
169
                    return;
170
                default:
171
                    break;
172
            }
173
        }
174
    }
175

176
    public Screen findByName(String name)
177
    {
178
        for (int i = 0; i < count; i++)
179
        {
180
            if (screens[i].getName().equals(name))
181
            {
182
                return screens[i];
183
            }
184
        }
185
        return null;
186
    }
187

188
    public Screen getScreen(int index)
189
    {
190
        if (index < 0 || index >= count)
191
        {
192
            throw new IndexOutOfBoundsException("상영관 번호가 범위를 벗어났습니다: " + index);
193
        }
194
        return screens[index];
195
    }
196

197
    public Screen[] getScreens()
198
    {
199
        if (count == 0)
200
        {
201
            return null;
202
        }
203
        return screens;
204
    }
205

206
    public int getMaxCount()
207
    {
208
        return maxCount;
209
    }
210

211
    public int getCount()
212
    {
213
        return count;
214
    }
215
}

1
public class Movie
2
{
3
    private String title;
4
    private String openDate;
5
    private int playtime;
6
    private String grade;
7

8
    public Movie(String title, String openDate, int playtime, String grade)
9
    {
10
        this.title = title;
11
        this.openDate = openDate;
12
        this.playtime = playtime;
13
        this.grade = grade;
14
    }
15

16
    /** 예) 2014-11-06 개봉 / 169분 / 12세이상관람가 */
17
    public String getSummary()
18
    {
19
        return openDate + " 개봉 / " + playtime + "분 / " + grade;
20
    }
21

22
    public String getTitle()
23
    {
24
        return title;
25
    }
26

27
    public void setTitle(String title)
28
    {
29
        this.title = title;
30
    }
31

32
    public String getOpenDate()
33
    {
34
        return openDate;
35
    }
36

37
    public void setOpenDate(String openDate)
38
    {
39
        this.openDate = openDate;
40
    }
41

42
    public int getPlaytime()
43
    {
44
        return playtime;
45
    }
46

47
    public void setPlaytime(int playtime)
48
    {
49
        this.playtime = playtime;
50
    }
51

52
    public String getGrade()
53
    {
54
        return grade;
55
    }
56

57
    public void setGrade(String grade)
58
    {
59
        this.grade = grade;
60
    }
61
}

1
import java.util.Arrays;
2

3
/**
4
 * 한 상영관에서 한 영화를 상영하는 일정. (상영 시작시간 여러 개)
5
 */
6
public class MovieTimetable
7
{
8
    private static final int MINUTES_OF_DAY = 24 * 60;
9

10
    private Movie movie;
11
    private Screen screen;
12
    private String[] times;
13

14
    public MovieTimetable(Movie movie, Screen screen, String[] times)
15
    {
16
        this.movie = movie;
17
        this.screen = screen;
18
        this.times = times;
19
    }
20

21
    /**
22
     * "10:00 13:30 17:00" 형태의 문자열을 검사한 뒤 정렬된 시간 배열로 변환한다.
23
     * 형식이 틀리거나, 중복되거나, 러닝타임 때문에 회차가 겹치면 IllegalArgumentException 을 던진다.
24
     */
25
    public static String[] parseTimes(String input, int playtime)
26
    {
27
        String trimmed = input.trim();
28
        if (trimmed.isEmpty())
29
        {
30
            throw new IllegalArgumentException("상영 시작시간을 하나 이상 입력해주세요.");
31
        }
32

33
        String[] tokens = trimmed.split("[\\s,]+");
34
        int[] minutes = new int[tokens.length];
35
        for (int i = 0; i < tokens.length; i++)
36
        {
37
            minutes[i] = toMinutes(tokens[i]);
38
        }
39
        Arrays.sort(minutes);
40

41
        for (int i = 1; i < minutes.length; i++)
42
        {
43
            if (minutes[i] == minutes[i - 1])
44
            {
45
                throw new IllegalArgumentException(formatMinutes(minutes[i]) + " 이(가) 중복 입력되었습니다.");
46
            }
47
            if (minutes[i] - minutes[i - 1] < playtime)
48
            {
49
                throw new IllegalArgumentException(formatMinutes(minutes[i - 1]) + " 회차(종료 "
50
                        + formatMinutes(minutes[i - 1] + playtime) + ")와 " + formatMinutes(minutes[i])
51
                        + " 회차가 겹칩니다. (러닝타임 " + playtime + "분)");
52
            }
53
        }
54

55
        String[] result = new String[minutes.length];
56
        for (int i = 0; i < minutes.length; i++)
57
        {
58
            result[i] = formatMinutes(minutes[i]);
59
        }
60
        return result;
61
    }
62

63
    private static int toMinutes(String time)
64
    {
65
        if (!time.matches("\\d{1,2}:\\d{2}"))
66
        {
67
            throw new IllegalArgumentException("'" + time + "'은(는) 올바른 시간 형식이 아닙니다. 예) 09:30 13:00");
68
        }
69
        String[] parts = time.split(":");
70
        int hour = Integer.parseInt(parts[0]);
71
        int minute = Integer.parseInt(parts[1]);
72
        if (hour > 23 || minute > 59)
73
        {
74
            throw new IllegalArgumentException("'" + time + "'은(는) 존재하지 않는 시간입니다. (00:00 ~ 23:59)");
75
        }
76
        return hour * 60 + minute;
77
    }
78

79
    /** 분 단위 값을 HH:mm 으로. 다음날로 넘어가면 (+1) 표시 */
80
    private static String formatMinutes(int total)
81
    {
82
        int m = total % MINUTES_OF_DAY;
83
        String text = String.format("%02d:%02d", m / 60, m % 60);
84
        if (total >= MINUTES_OF_DAY)
85
        {
86
            text += "(+1)";
87
        }
88
        return text;
89
    }
90

91
    /** 시작시간으로부터 러닝타임을 더한 종료시간 */
92
    public String getEndTime(String startTime)
93
    {
94
        return formatMinutes(toMinutes(startTime) + movie.getPlaytime());
95
    }
96

97
    public boolean hasTime(String time)
98
    {
99
        for (String t : times)
100
        {
101
            if (t.equals(time))
102
            {
103
                return true;
104
            }
105
        }
106
        return false;
107
    }
108

109
    /** 예) 10:00, 13:30, 17:00 */
110
    public String getTimesText()
111
    {
112
        StringBuilder sb = new StringBuilder();
113
        for (int i = 0; i < times.length; i++)
114
        {
115
            if (i > 0)
116
            {
117
                sb.append(", ");
118
            }
119
            sb.append(times[i]);
120
        }
121
        return sb.toString();
122
    }
123

124
    public void showTime()
125
    {
126
        System.out.print(getTimesText());
127
    }
128

129
    public Movie getMovie()
130
    {
131
        return movie;
132
    }
133

134
    public void setMovie(Movie movie)
135
    {
136
        this.movie = movie;
137
    }
138

139
    public Screen getScreen()
140
    {
141
        return screen;
142
    }
143

144
    public void setScreen(Screen screen)
145
    {
146
        this.screen = screen;
147
    }
148

149
    public String[] getTimes()
150
    {
151
        return times;
152
    }
153

154
    public void setTimes(String[] times)
155
    {
156
        this.times = times;
157
    }
158
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.time.format.DateTimeParseException;
4
import java.util.ArrayList;
5
import java.util.List;
6

7
public class TimetableManager
8
{
9
    private static final String[] GRADES = {"전체관람가", "12세이상관람가", "15세이상관람가", "청소년관람불가"};
10
    private static final int MAX_TITLE_WIDTH = 30;
11
    private static final int MAX_PLAYTIME = 600;
12

13
    private MovieTimetable[] table;
14
    private ScreenManager sm;
15
    private TicketManager ticketManager; // 잔여석 표시, 예매가 있는 일정 삭제 방지용
16
    private int pos;
17

18
    public TimetableManager(int n, ScreenManager sm)
19
    {
20
        table = new MovieTimetable[n];
21
        this.sm = sm;
22
        pos = 0;
23
    }
24

25
    public void setTicketManager(TicketManager ticketManager)
26
    {
27
        this.ticketManager = ticketManager;
28
    }
29

30
    // ------------------------------------------------------------------ 등록
31

32
    public void add()
33
    {
34
        ConsoleUI.section("상영일정 등록");
35
        if (sm.getCount() == 0)
36
        {
37
            ConsoleUI.error("등록된 상영관이 없습니다.");
38
            ConsoleUI.info("메인 메뉴 1번(상영관 관리)에서 상영관을 먼저 등록해주세요.");
39
            return;
40
        }
41
        if (isFull())
42
        {
43
            ConsoleUI.error("상영일정이 가득 찼습니다. (최대 " + table.length + "개)");
44
            ConsoleUI.info("기존 상영일정을 삭제한 뒤 다시 시도해주세요.");
45
            return;
46
        }
47
        if (getAvailableScreens().isEmpty())
48
        {
49
            ConsoleUI.error("모든 상영관에 이미 상영일정이 있습니다. (상영관 1곳당 영화 1편)");
50
            ConsoleUI.info("상영관을 새로 등록하거나 기존 상영일정을 삭제해주세요.");
51
            return;
52
        }
53

54
        Movie movie = selectOrCreateMovie();
55
        if (movie == null)
56
        {
57
            ConsoleUI.info("상영일정 등록을 취소했습니다.");
58
            return;
59
        }
60

61
        int added = 0;
62
        while (true)
63
        {
64
            if (isFull())
65
            {
66
                ConsoleUI.info("상영일정이 가득 차서 더 이상 등록할 수 없습니다.");
67
                break;
68
            }
69
            List<Screen> available = getAvailableScreens();
70
            if (available.isEmpty())
71
            {
72
                ConsoleUI.info("일정을 추가할 수 있는 빈 상영관이 더 없습니다.");
73
                break;
74
            }
75

76
            System.out.println();
77
            System.out.println("  '" + movie.getTitle() + "'을(를) 상영할 상영관을 선택하세요. (비어 있는 상영관만 표시)");
78
            List<String[]> rows = new ArrayList<String[]>();
79
            for (int i = 0; i < available.size(); i++)
80
            {
81
                Screen sc = available.get(i);
82
                rows.add(new String[] {String.valueOf(i + 1), sc.getName(), sc.getLayoutText(), sc.getTotalSeats() + "석"});
83
            }
84
            ConsoleUI.printTable(new String[] {"번호", "상영관", "좌석 배치", "총 좌석"}, rows);
85

86
            String zeroLabel = (added == 0) ? "0. 취소" : "0. 등록 마치기";
87
            int select = ConsoleInput.readInt("상영관 번호 (" + zeroLabel + ") >> ", 0, available.size());
88
            if (select == 0)
89
            {
90
                break;
91
            }
92
            Screen screen = available.get(select - 1);
93

94
            String[] times = readTimes(movie);
95
            if (times == null)
96
            {
97
                ConsoleUI.info("'" + screen.getName() + "' 일정 입력을 취소했습니다.");
98
                continue;
99
            }
100

101
            MovieTimetable mt = new MovieTimetable(movie, screen, times);
102
            addTimetable(mt);
103
            added++;
104
            ConsoleUI.success(screen.getName() + "에 '" + movie.getTitle() + "' " + times.length + "회차가 등록되었습니다.");
105
            for (String t : times)
106
            {
107
                System.out.println("         " + t + " ~ " + mt.getEndTime(t));
108
            }
109
        }
110

111
        if (added == 0)
112
        {
113
            ConsoleUI.info("등록된 상영일정이 없습니다.");
114
        } else
115
        {
116
            ConsoleUI.success("총 " + added + "개 상영관에 '" + movie.getTitle() + "' 일정이 등록되었습니다. [" + pos + "/"
117
                    + table.length + "]");
118
        }
119
    }
120

121
    /** 기존 영화 중 선택하거나 새 영화를 입력받는다. 취소하면 null */
122
    private Movie selectOrCreateMovie()
123
    {
124
        List<Movie> movies = getMovies();
125
        if (movies.isEmpty())
126
        {
127
            ConsoleUI.info("등록된 영화가 없어 새 영화 정보를 입력합니다.");
128
            return createMovie();
129
        }
130

131
        System.out.println("  등록된 영화 목록");
132
        List<String[]> rows = new ArrayList<String[]>();
133
        for (int i = 0; i < movies.size(); i++)
134
        {
135
            Movie m = movies.get(i);
136
            rows.add(new String[] {String.valueOf(i + 1), m.getTitle(), m.getOpenDate(), m.getPlaytime() + "분", m.getGrade()});
137
        }
138
        ConsoleUI.printTable(new String[] {"번호", "제목", "개봉일", "러닝타임", "등급"}, rows);
139
        int select = ConsoleInput.readInt("영화 번호 (0. 새 영화 등록) >> ", 0, movies.size());
140
        if (select == 0)
141
        {
142
            return createMovie();
143
        }
144
        return movies.get(select - 1);
145
    }
146

147
    private Movie createMovie()
148
    {
149
        String title;
150
        while (true)
151
        {
152
            title = ConsoleInput.readLine("영화 제목 (빈 입력 시 취소) : ");
153
            if (title.isEmpty())
154
            {
155
                return null;
156
            }
157
            if (ConsoleUI.displayWidth(title) > MAX_TITLE_WIDTH)
158
            {
159
                ConsoleUI.error("제목이 너무 깁니다. (한글 15자 / 영문 30자 이내)");
160
                continue;
161
            }
162
            break;
163
        }
164
        Movie existing = findMovie(title);
165
        if (existing != null)
166
        {
167
            ConsoleUI.info("'" + title + "'은(는) 이미 등록된 영화입니다. 기존 정보(" + existing.getSummary() + ")를 사용합니다.");
168
            return existing;
169
        }
170

171
        String openDate = readDate("개봉일 (예: 2026-09-24 또는 20260924) : ");
172
        int playtime = ConsoleInput.readInt("러닝타임 (분, 1~" + MAX_PLAYTIME + ") : ", 1, MAX_PLAYTIME);
173

174
        System.out.print("  등급 -");
175
        for (int i = 0; i < GRADES.length; i++)
176
        {
177
            System.out.print("  " + (i + 1) + "." + GRADES[i]);
178
        }
179
        System.out.println();
180
        int gradeNo = ConsoleInput.readInt("등급 번호 (1~" + GRADES.length + ") : ", 1, GRADES.length);
181

182
        Movie movie = new Movie(title, openDate, playtime, GRADES[gradeNo - 1]);
183
        ConsoleUI.success("새 영화 '" + title + "' 정보가 입력되었습니다. (" + movie.getSummary() + ")");
184
        return movie;
185
    }
186

187
    private String readDate(String prompt)
188
    {
189
        while (true)
190
        {
191
            String input = ConsoleInput.readLine(prompt);
192
            try
193
            {
194
                LocalDate date = input.contains("-")
195
                        ? LocalDate.parse(input, DateTimeFormatter.ISO_LOCAL_DATE)
196
                        : LocalDate.parse(input, DateTimeFormatter.BASIC_ISO_DATE);
197
                return date.toString();
198
            } catch (DateTimeParseException e)
199
            {
200
                ConsoleUI.error("'" + input + "'은(는) 올바른 날짜가 아닙니다. 예) 2026-09-24");
201
            }
202
        }
203
    }
204

205
    /** 상영 시작시간을 입력받는다. 빈 입력이면 null */
206
    private String[] readTimes(Movie movie)
207
    {
208
        System.out.println("  상영 시작시간을 공백으로 구분해 입력하세요. (러닝타임 " + movie.getPlaytime() + "분, 회차끼리 겹칠 수 없음)");
209
        while (true)
210
        {
211
            String input = ConsoleInput.readLine("시작시간 (예: 10:00 13:30, 빈 입력 시 취소) : ");
212
            if (input.isEmpty())
213
            {
214
                return null;
215
            }
216
            try
217
            {
218
                return MovieTimetable.parseTimes(input, movie.getPlaytime());
219
            } catch (IllegalArgumentException e)
220
            {
221
                ConsoleUI.error(e.getMessage());
222
            }
223
        }
224
    }
225

226
    /** 입력 없이 상영일정을 추가한다. (샘플 데이터 및 add() 내부에서 사용) */
227
    public boolean addTimetable(MovieTimetable mt)
228
    {
229
        if (isFull() || findByScreen(mt.getScreen()) != null)
230
        {
231
            return false;
232
        }
233
        table[pos] = mt;
234
        pos++;
235
        sort();
236
        return true;
237
    }
238

239
    /** 영화 제목 → 상영관 이름 순으로 정렬 (버블 정렬) */
240
    private void sort()
241
    {
242
        for (int i = 0; i < pos - 1; i++)
243
        {
244
            for (int j = 0; j < pos - 1 - i; j++)
245
            {
246
                int cmp = table[j].getMovie().getTitle().compareTo(table[j + 1].getMovie().getTitle());
247
                if (cmp == 0)
248
                {
249
                    cmp = table[j].getScreen().getName().compareTo(table[j + 1].getScreen().getName());
250
                }
251
                if (cmp > 0)
252
                {
253
                    MovieTimetable temp = table[j];
254
                    table[j] = table[j + 1];
255
                    table[j + 1] = temp;
256
                }
257
            }
258
        }
259
    }
260

261
    // ------------------------------------------------------------------ 목록
262

263
    public void list()
264
    {
265
        ConsoleUI.section("상영일정 목록 (" + pos + "/" + table.length + ")");
266
        if (pos == 0)
267
        {
268
            ConsoleUI.info("등록된 상영일정이 없습니다. 1번(등록)으로 추가해보세요.");
269
            return;
270
        }
271

272
        List<Movie> movies = getMovies();
273
        for (int i = 0; i < movies.size(); i++)
274
        {
275
            Movie m = movies.get(i);
276
            System.out.println();
277
            System.out.println("  [" + (i + 1) + "] " + m.getTitle() + "   " + m.getSummary());
278
            for (int k = 0; k < pos; k++)
279
            {
280
                if (table[k].getMovie() != m)
281
                {
282
                    continue;
283
                }
284
                Screen sc = table[k].getScreen();
285
                System.out.println("      - " + sc.getName() + " (" + sc.getLayoutText() + ")");
286
                for (String t : table[k].getTimes())
287
                {
288
                    String line = "          " + t + " ~ " + table[k].getEndTime(t);
289
                    if (ticketManager != null)
290
                    {
291
                        int remain = sc.getTotalSeats() - ticketManager.countReserved(sc, t);
292
                        line += "   " + (remain == 0 ? "매진" : "잔여 " + remain + "/" + sc.getTotalSeats() + "석");
293
                    }
294
                    System.out.println(line);
295
                }
296
            }
297
        }
298
    }
299

300
    // ------------------------------------------------------------------ 삭제
301

302
    public void remove()
303
    {
304
        ConsoleUI.section("상영일정 삭제");
305
        if (pos == 0)
306
        {
307
            ConsoleUI.info("삭제할 상영일정이 없습니다.");
308
            return;
309
        }
310

311
        List<String[]> rows = new ArrayList<String[]>();
312
        for (int i = 0; i < pos; i++)
313
        {
314
            int ticketCount = (ticketManager == null) ? 0 : ticketManager.countTickets(table[i].getScreen());
315
            rows.add(new String[] {
316
                    String.valueOf(i + 1),
317
                    table[i].getMovie().getTitle(),
318
                    table[i].getScreen().getName(),
319
                    table[i].getTimesText(),
320
                    ticketCount + "건"
321
            });
322
        }
323
        ConsoleUI.printTable(new String[] {"번호", "영화", "상영관", "상영시간", "예매"}, rows);
324

325
        int select = ConsoleInput.readInt("삭제할 일정 번호 (0. 취소) >> ", 0, pos);
326
        if (select == 0)
327
        {
328
            ConsoleUI.info("삭제를 취소했습니다.");
329
            return;
330
        }
331
        int index = select - 1;
332
        MovieTimetable target = table[index];
333
        String label = "'" + target.getMovie().getTitle() + "' / " + target.getScreen().getName();
334

335
        if (ticketManager != null && ticketManager.countTickets(target.getScreen()) > 0)
336
        {
337
            ConsoleUI.error(label + " 일정에 예매 내역이 있어 삭제할 수 없습니다.");
338
            ConsoleUI.info("티켓 예매 메뉴에서 해당 예매를 먼저 취소해주세요.");
339
            return;
340
        }
341
        if (!ConsoleInput.confirm(label + " 상영일정을 삭제할까요?"))
342
        {
343
            ConsoleUI.info("삭제를 취소했습니다.");
344
            return;
345
        }
346

347
        for (int j = index; j < pos - 1; j++)
348
        {
349
            table[j] = table[j + 1];
350
        }
351
        table[pos - 1] = null;
352
        pos--;
353
        ConsoleUI.success(label + " 상영일정이 삭제되었습니다.");
354
    }
355

356
    public void timetableManagerMain()
357
    {
358
        while (true)
359
        {
360
            ConsoleUI.title("상영일정 관리  (등록 " + pos + "/" + table.length + ")");
361
            System.out.println("  1. 상영일정 등록");
362
            System.out.println("  2. 상영일정 목록");
363
            System.out.println("  3. 상영일정 삭제");
364
            System.out.println("  0. 메인 메뉴로");
365
            int input = ConsoleInput.readInt("메뉴 선택 >> ", 0, 3);
366
            switch (input)
367
            {
368
                case 1:
369
                    add();
370
                    break;
371
                case 2:
372
                    list();
373
                    break;
374
                case 3:
375
                    remove();
376
                    break;
377
                case 0:
378
                    return;
379
                default:
380
                    break;
381
            }
382
        }
383
    }
384

385
    // ------------------------------------------------------------------ 조회용
386

387
    /** 중복 없는 영화 목록 (정렬 순서 유지) */
388
    public List<Movie> getMovies()
389
    {
390
        List<Movie> movies = new ArrayList<Movie>();
391
        for (int i = 0; i < pos; i++)
392
        {
393
            if (!movies.contains(table[i].getMovie()))
394
            {
395
                movies.add(table[i].getMovie());
396
            }
397
        }
398
        return movies;
399
    }
400

401
    private Movie findMovie(String title)
402
    {
403
        for (int i = 0; i < pos; i++)
404
        {
405
            if (table[i].getMovie().getTitle().equals(title))
406
            {
407
                return table[i].getMovie();
408
            }
409
        }
410
        return null;
411
    }
412

413
    public MovieTimetable findByScreen(Screen screen)
414
    {
415
        for (int i = 0; i < pos; i++)
416
        {
417
            if (table[i].getScreen() == screen)
418
            {
419
                return table[i];
420
            }
421
        }
422
        return null;
423
    }
424

425
    private List<Screen> getAvailableScreens()
426
    {
427
        List<Screen> result = new ArrayList<Screen>();
428
        for (int i = 0; i < sm.getCount(); i++)
429
        {
430
            Screen sc = sm.getScreen(i);
431
            if (findByScreen(sc) == null)
432
            {
433
                result.add(sc);
434
            }
435
        }
436
        return result;
437
    }
438

439
    private boolean isFull()
440
    {
441
        return pos == table.length;
442
    }
443

444
    public int getPos()
445
    {
446
        return pos;
447
    }
448

449
    public int getMaxCount()
450
    {
451
        return table.length;
452
    }
453

454
    public MovieTimetable[] getMT()
455
    {
456
        return table;
457
    }
458
}