duo_cafe_comment 0.0.50 → 0.0.52

data/lib/duo_cafe_comment.rb

@@ -219,19 +219,29 @@ class Naver
             begin
                 wait = Selenium::WebDriver::Wait.new(:timeout => 7)
                 #요소가 나타날 때까지 3초 동안 기다립니다.
-                wait.until { @driver.find_element(:xpath, '//*[@for="switch"]') }
-                sleep(1.5)
-                @driver.find_element(:xpath, '//*[@id="login_keep_wrap"]/div[1]/label').click
-                sleep(1.5)
-                @driver.find_element(:xpath, '//*[@id="id"]').click
+                wait.until { @driver.find_element(:xpath, '//*[@id="id" and @name="id"]') }
+                @driver.find_element(:xpath, '//*[@id="id" and @name="id"]').click
                 Clipboard.copy(user_id)
                 @driver.action.key_down(:control).send_keys('v').key_up(:control).perform
                 sleep(1.5)
-                @driver.find_element(:xpath, '//*[@id="pw"]').click
+                @driver.find_element(:xpath, '//*[@id="pw" and @name="pw"]').click
                 Clipboard.copy(user_pw)
                 @driver.action.key_down(:control).send_keys('v').key_up(:control).perform
                 sleep(1.5)
-                @driver.find_element(:xpath, '//*[@id="log.login"]').click
+
+                begin
+                smart_level_value = @driver.find_element(id: 'smart_LEVEL').attribute('value')
+                    if smart_level_value == '1'
+                    @driver.find_element(xpath: '//label[@for="switch" and @class="switch_btn"]').click
+                    sleep(1.5)
+                    end
+                rescue
+                end
+
+                wait = Selenium::WebDriver::Wait.new(:timeout => 3)
+                #요소가 나타날 때까지 3초 동안 기다립니다.
+                wait.until { @driver.find_element(xpath: '//button[@type="submit" and @id="log.login"]') }
+                @driver.find_element(xpath: '//button[@type="submit" and @id="log.login"]').click
                 sleep(2.5)
             rescue => e
                 puts '-[√] 로딩 지연 접속 실패.......'.red
@@ -253,9 +263,9 @@ class Naver
         end
 
         begin
-            wait = Selenium::WebDriver::Wait.new(:timeout => 3)
+            wait = Selenium::WebDriver::Wait.new(:timeout => 5)
             #요소가 나타날 때까지 3초 동안 기다립니다.
-            wait.until { @driver.find_element(:xpath, '//*[@class="MyView-module__btn_logout___bsTOJ"]') }
+            wait.until { @driver.find_element(:xpath, '//*[@type="button" and @class="MyView-module__btn_logout___bsTOJ"]') }
         
         rescue => e
             puts '-[√] 로그인 실패.......'.red
@@ -493,36 +503,7 @@ class Naver
             sleep(1)
             @driver.switch_to.frame(@driver.find_element(:xpath, '//*[@id="cafe_main"]'))   # 아이프레임 선택
            
-            if @data['포스트설정']['순서사용2'].checked?
-                @content_soon ||= 0  # 초기 한 번만 0으로 세팅
-
-                if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
-                    content = ''
-                else
-                    if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
-                        content = @data['내용설정']['내용'].sample[2]
-                    else
-                        content = @data['내용설정']['내용'][@content_soon][2]
-                        @content_soon += 1
-                        @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
-                    end
-                end
-            else 
-            end 
-                    
-            # 디엠 자동 변경이 체크된 경우 content를 변환
-            if @data['포스트설정']['내용자동변경'].checked?
-                change_memory = {}
-                @data['포스트설정']['내용자동변경값'].each do |key, v|
-                change_memory[key] = v.sample
-                end
-                @data['포스트설정']['내용자동변경값'].each do |key, _|
-                    if content.include?(key)
-                    content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
-                    else
-                    end
-                end
-            end    
+                     
 
             if option['좋아요'] == 'true'
                 puts "좋아요 클릭 옵션 진행!!".cyan
@@ -551,363 +532,1474 @@ class Naver
             else
             end    
 
-
-                begin
-                wait = Selenium::WebDriver::Wait.new(:timeout => 10)
-                wait.until { @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]') }
-    
-                # 댓글 입력
-                element = @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]')
-                @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)#크롤 이동
-                sleep(1)
-                if option['ChatGPT사용'] == 'true'
-                    pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
-                    sleep(1)
-                  
-                    puts "ChatGPT로 댓글을 만드는 중입니다."
-                    @api_key = api_key
-                    url = 'https://api.openai.com/v1/chat/completions'
-                    headers = {
-                      'Content-Type' => 'application/json',
-                      'Authorization' => 'Bearer ' + @api_key
-                    }
-                    data = {
-                      'model' => 'gpt-3.5-turbo',
-                      'messages' => [
-                        { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
-                        { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
-                      ]
-                    }
-                  
-                    begin
-                      req = HTTP.headers(headers).post(url, json: data)
-                      puts "HTTP Status: #{req.status}" # 상태 코드 확인
-                      response = JSON.parse(req.body.to_s)
-                      puts "API Response: #{response}" # 전체 응답 출력
-                  
-                      if req.status == 429
-                        return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
-                      end
                   
-                      # 응답 데이터에서 안전하게 값 추출
-                      raw_answer = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
-                      answer = raw_answer.gsub(/\. /, ".\n") # 줄바꿈 추가
                   
-                    rescue => e
-                      puts "Error: #{e.message}"
-                      answer = "오류가 발생했습니다."
-                    end
-                  
-                    # 댓글 입력
-                    @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]').send_keys(answer)
-                    sleep(1)
-                else
-                    begin
-                        puts (content)
-                        @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]').send_keys(content)
-                        sleep(1)
-                    rescue
-                    end
-                end  
-                
-                # 이모티콘 자동 삽입
-                if option['이모티콘자동삽입'] == 'true'
-                    puts "이모티콘 자동 삽입 옵션 진행!!".cyan
-                
-                    # '이모티콘' 버튼 클릭
-                    @driver.find_element(:xpath, '//*[@class="button_sticker"]').click
-                    sleep(1)
-                
+            if option['re_coment'] == 'true' # 대 댓글 작업때
+                if @data['포스트설정']['전체대댓글'].checked?
                     begin
-                    # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
-                    sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
-                
-                    # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
-                    random_li = sticker_list_elements.sample
-                    random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
-                    random_button.click
-                
-                    sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
-                    
-                    # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
-                    inner_buttons = random_li.find_elements(:tag_name, 'button')
-                
-                    # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
-                    random_button_in_li = inner_buttons.sample
-                    sleep(1)
-                    random_button_in_li.click
-                
-                    sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
-                    
-                    rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
-                    #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
-                    # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
-                    # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
-                    
-                    rescue => e
-                    puts "기타 오류로 인해 이모티콘 삽입 안됨"
-                    # 기타 오류 처리
-                    # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
-                    end
-                else
-                    puts "이모티콘 자동 삽입 옵션이 비활성화됨."
-                end
-    
-                # 이미지 자동 삽입
-                if option['이미지자동삽입'] == 'true'
-                    puts "이미지 자동 상입 옵션 진행!!".cyan
-    
-                    # 아이프레임 요소가 나타날 때까지 기다립니다.
-                    @image = image
-                    image_path = image  
-              
-                    @driver.find_element(:xpath, '//*[@for="attach2"]').click
-                    sleep(1)
-                    key_stroke('escape')  
-                    # 파일 경로 자동 입력
-                    file_input = @driver.find_element(:xpath, '//*[@id="attach2"]')
-    
-                    # send_keys로 파일 경로를 입력하여 이미지 업로드
-                    file_input.send_keys(image_path)
-                    sleep(2)    
-               
-                else
-                end
-    
-                wait.until { @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]') }
-                @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]').click
-                puts "#{board_url} [댓글 작성 완료 !!]".cyan
-            
-                sleep(2)
-                begin
-                    @driver.switch_to.alert
-                    sleep(1)
-                    error_text = @driver.switch_to.alert.text
-                    sleep(1)
-                    @driver.switch_to.alert.accept
-                    puts (error_text).red
-                    posting_url = @driver.current_url
-                    
-                    File.open('./log/posting_log.txt', 'a') do |ff|
-                    ff.write('[')   
-                    ff.write(DateTime.now.strftime("%Y년%m월%d일%H시%M분"))
-                    ff.write(']')  
-                    ff.write('　') 
-                    ff.write('【등록실패:')     
-                    ff.write(error_text)
-                    ff.write('】')
-                    ff.write('　')
-                    ff.write(posting_url)
-                    ff.close()
-                    puts '-[√] 로그 파일 생성 완료.......'.yellow     
-                    end   
-            
-                rescue
-                    #@driver.execute_script("document.body.style.zoom = '1.00'") 
-                    sleep(1)
-                    posting_url = @driver.current_url
-                    
-                    File.open('./log/posting_log.txt', 'a') do |ff|
-                    ff.write('[')   
-                    ff.write(DateTime.now.strftime("%Y년%m월%d일%H시%M분"))
-                    ff.write(']')  
-                    ff.write('　')  
-                    ff.write('【등록성공확인】') 
-                    ff.write('　')  
-                    ff.write(posting_url)
-                    ff.write("\n")
-                    ff.close()
-                    puts '-[√] 로그 파일 생성 완료.......'.yellow   
-                    end 
-                end         
-                end
-                @driver.switch_to.default_content()                                              # 아이프레임 해제
-                def sleep_with_progress(sleep_delay)
-                    print "[설정 딜레이 진행 중] "
-                    steps = (sleep_delay.to_f / 0.5).to_i
-                    steps.times do
-                        print "."
-                        STDOUT.flush
-                        sleep(1)
-                    end
-                    puts "\n"
-                end
+                        comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                        original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
 
-                sleep_with_progress(sleep_delay)
-                
+                        original_comments.each_with_index do |item, index|
 
-            rescue => e
-                puts "Error: #{e.message}"
-            end  
-            end
-        else
-        end
-    
-        ################################################################################ 설정게시글사용 ################################################################################
+                        begin
 
-        if option['설정게시글사용'] == 'true'
-        puts "게시판 list 기반으로 댓글 작업 옵션 진행!!".cyan
-        
-                @driver.get(board_url)  # 해당 URL로 이동
-                begin
-                # 아이프레임 요소가 나타날 때까지 기다립니다.
-                wait = Selenium::WebDriver::Wait.new(:timeout => 20)                            # 아이프레임 선택
-                wait.until { @driver.find_element(:xpath, '//*[@id="cafe_main"]') }             # 아이프레임 선택
-                sleep(1)
-                @driver.switch_to.frame(@driver.find_element(:xpath, '//*[@id="cafe_main"]'))   # 아이프레임 선택
-        
-                if @data['포스트설정']['순서사용2'].checked?
-                    @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+                            if @data['포스트설정']['순서사용2'].checked?
+                                @content_soon ||= 0  # 초기 한 번만 0으로 세팅
 
-                    if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
-                        content = ''
-                    else
-                        if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
-                            content = @data['내용설정']['내용'].sample[2]
-                        else
-                            content = @data['내용설정']['내용'][@content_soon][2]
-                            @content_soon += 1
-                            @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
-                        end
-                    end
-                else 
-                end 
-                    
-                # 디엠 자동 변경이 체크된 경우 content를 변환
-                if @data['포스트설정']['내용자동변경'].checked?
-                    change_memory = {}
-                    @data['포스트설정']['내용자동변경값'].each do |key, v|
-                    change_memory[key] = v.sample
-                    end
-                    @data['포스트설정']['내용자동변경값'].each do |key, _|
-                        if content.include?(key)
-                        content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
-                        else
-                        end
-                    end
-                end
+                                if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                    content = ''
+                                else
+                                    if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                        content = @data['내용설정']['내용'].sample[2]
+                                    else
+                                        content = @data['내용설정']['내용'][@content_soon][2]
+                                        @content_soon += 1
+                                        @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                    end
+                                end
+                            else 
+                            end 
+                                    
+                            # 디엠 자동 변경이 체크된 경우 content를 변환
+                            if @data['포스트설정']['내용자동변경'].checked?
+                                change_memory = {}
+                                @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                change_memory[key] = v.sample
+                                end
+                                @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                    if content.include?(key)
+                                    content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                    else
+                                    end
+                                end
+                            end    
 
+                            if option['ChatGPT사용'] == 'true'
+                                    pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                    sleep(1)
+                                
+                                    puts "ChatGPT로 댓글을 만드는 중입니다."
+                                    @api_key = api_key
+                                    url = 'https://api.openai.com/v1/chat/completions'
+                                    headers = {
+                                    'Content-Type' => 'application/json',
+                                    'Authorization' => 'Bearer ' + @api_key
+                                    }
+                                    data = {
+                                    'model' => 'gpt-3.5-turbo',
+                                    'messages' => [
+                                        { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                        { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                    ]
+                                    }
+                                
+                                    begin
+                                    req = HTTP.headers(headers).post(url, json: data)
+                                    puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                    response = JSON.parse(req.body.to_s)
+                                    puts "API Response: #{response}" # 전체 응답 출력
+                                
+                                    if req.status == 429
+                                        return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                    end
+                                
+                                    # 응답 데이터에서 안전하게 값 추출
+                                    raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                    content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                
+                                    rescue => e
+                                    puts "Error: #{e.message}"
+                                    content = "오류가 발생했습니다."
+                                    end
+                            else
+                            end 
 
-                if option['좋아요'] == 'true'
-                    puts "좋아요 클릭 옵션 진행!!".cyan
-                    wait = Selenium::WebDriver::Wait.new(:timeout => 10)
-                    wait.until { @driver.find_element(:xpath, '//*[@class="u_ico _icon"]') }
-        
-                    # 댓글 입력
-                    element = @driver.find_element(:xpath, '//*[@class="u_ico _icon"]')
-                    @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)#크롤 이동
-                    sleep(1)
-        
-                    # 좋아요 버튼을 찾기
-                    like_button = @driver.find_element(:xpath, '//div[@class="ReactionLikeIt u_likeit_list_module _cafeReactionModule"]//a[@role="button"]')
-        
-                    # aria-pressed 속성 값 확인
-                    aria_pressed = like_button.attribute('aria-pressed')
-        
-                    if aria_pressed == 'true'
-                    # 이미 좋아요를 누른 상태일 경우
-                    
-                    else
-                    # 좋아요를 아직 누르지 않은 상태일 경우 클릭
-                    @driver.find_element(:xpath, '//*[@class="u_ico _icon"]').click
-                    sleep(2)
-                    end
-                else
-                end  
-        
-        
-                    begin
-                    wait = Selenium::WebDriver::Wait.new(:timeout => 10)
-                    wait.until { @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]') }
+                            reply_button = item.find_element(:css, 'a.comment_info_button')
+                            puts "대댓글 #{index + 1} 작성 중..."
+                            reply_button.click
+                            sleep(1.5)
+
+                            textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                            textarea.send_keys(content)
+                            sleep(1)
+
+                            if option['이모티콘자동삽입'] == 'true'
+                                puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                reply_comments.each_with_index do |item, index|
+                                    begin
+                                        
+                                        
+                                        # 해당 대댓글 내부의 이모티콘 버튼 찾기
+                                        sticker_button = item.find_element(:css, 'a.button_sticker')
+                                        sticker_button.click
+                                        sleep(1)
+                                        
+                                    rescue
+                                    end
+                                end
+                                begin
+                                # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                                sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                                    
+                                # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                                random_li = sticker_list_elements.sample
+                                random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                                random_button.click
+                                                    
+                                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                                inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                                    
+                                # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                                random_button_in_li = inner_buttons.sample
+                                sleep(1)
+                                random_button_in_li.click
+                                                    
+                                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                                #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                                # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                                # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+
+                                rescue => e
+                                puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                # 기타 오류 처리
+                                # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                                end
+                            else
+                                puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                            end
         
-                    # 댓글 입력
-                    element = @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]')
-                    @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)#크롤 이동
-                    sleep(1)
-                    if option['ChatGPT사용'] == 'true'
-                        pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
-                        sleep(1)
-                      
-                        puts "ChatGPT로 댓글을 만드는 중입니다."
-                        @api_key = api_key
-                        url = 'https://api.openai.com/v1/chat/completions'
-                        headers = {
-                          'Content-Type' => 'application/json',
-                          'Authorization' => 'Bearer ' + @api_key
-                        }
-                        data = {
-                          'model' => 'gpt-3.5-turbo',
-                          'messages' => [
-                            { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
-                            { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
-                          ]
-                        }
-                      
-                        begin
-                          req = HTTP.headers(headers).post(url, json: data)
-                          puts "HTTP Status: #{req.status}" # 상태 코드 확인
-                          response = JSON.parse(req.body.to_s)
-                          puts "API Response: #{response}" # 전체 응답 출력
-                      
-                          if req.status == 429
-                            return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
-                          end
-                      
-                          # 응답 데이터에서 안전하게 값 추출
-                          raw_answer = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
-                          answer = raw_answer.gsub(/\. /, ".\n") # 줄바꿈 추가
-                      
+                            # 이미지 자동 삽입
+                            if option['이미지자동삽입'] == 'true'
+                                puts "이미지 자동 상입 옵션 진행!!".cyan
+                                        
+                                # 아이프레임 요소가 나타날 때까지 기다립니다.
+                                @image = image
+                                image_path = image  
+                                reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+
+                                reply_comments.each_with_index do |item, index|
+                                    begin
+                                        
+
+                                        # 해당 대댓글 내부에서 for="attach2"인 라벨 클릭
+                                        attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                        attach_button.click
+                                        sleep(1)
+
+                                    rescue
+                                    end
+                                end
+                                key_stroke('escape')  
+                                # 파일 경로 자동 입력
+                                file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                        
+                                # send_keys로 파일 경로를 입력하여 이미지 업로드
+                                file_input.send_keys(image_path)
+                                sleep(2)    
+                        
+                            else
+                            end
+
+                            register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                            register_btn.click
+                            sleep(2)
+
                         rescue => e
-                          puts "Error: #{e.message}"
-                          answer = "오류가 발생했습니다."
-                        end
-                      
-                        # 댓글 입력
-                        @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]').send_keys(answer)
-                        sleep(1)
-                    else
-                        begin
-                            puts (content)
-                            @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]').send_keys(content)
-                            sleep(1)
-                        rescue
+                            puts "대댓글 #{index + 1} 처리 중 오류 발생: #{e.message}"
+                            next
+                            end
                         end
-                    end  
-                    
-                    # 이모티콘 자동 삽입
-                    if option['이모티콘자동삽입'] == 'true'
-                        puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                    rescue => e
+                        puts "전체대댓글 처리 중 예외 발생: #{e.message}"
+                    end
+
+                elsif @data['포스트설정']['지정대댓글'].checked? 
+                    targets = @data['포스트설정']['nik_or_number'].text.to_s.force_encoding('utf-8').split(',').map(&:strip)
+                    targets.each do |target|
+                        if target.match?(/^\d+$/)
+                            index = target.to_i - 1
+                            comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                            original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                            if original_comments[index]
+                                begin
+
+                                    if @data['포스트설정']['순서사용2'].checked?
+                                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                            content = ''
+                                        else
+                                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                                content = @data['내용설정']['내용'].sample[2]
+                                            else
+                                                content = @data['내용설정']['내용'][@content_soon][2]
+                                                @content_soon += 1
+                                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                            end
+                                        end
+                                    else 
+                                    end 
+                                            
+                                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                                    if @data['포스트설정']['내용자동변경'].checked?
+                                        change_memory = {}
+                                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                        change_memory[key] = v.sample
+                                        end
+                                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                            if content.include?(key)
+                                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                            else
+                                            end
+                                        end
+                                    end    
+
+                                    if option['ChatGPT사용'] == 'true'
+                                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                            sleep(1)
+                                        
+                                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                                            @api_key = api_key
+                                            url = 'https://api.openai.com/v1/chat/completions'
+                                            headers = {
+                                            'Content-Type' => 'application/json',
+                                            'Authorization' => 'Bearer ' + @api_key
+                                            }
+                                            data = {
+                                            'model' => 'gpt-3.5-turbo',
+                                            'messages' => [
+                                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                            ]
+                                            }
+                                        
+                                            begin
+                                            req = HTTP.headers(headers).post(url, json: data)
+                                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                            response = JSON.parse(req.body.to_s)
+                                            puts "API Response: #{response}" # 전체 응답 출력
+                                        
+                                            if req.status == 429
+                                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                            end
+                                        
+                                            # 응답 데이터에서 안전하게 값 추출
+                                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                        
+                                            rescue => e
+                                            puts "Error: #{e.message}"
+                                            content = "오류가 발생했습니다."
+                                            end
+                                    else
+                                    end 
+
+                                    puts "#{index + 1}번째 댓글에 대댓글 작성 시작"
+                                    reply_button = original_comments[index].find_element(:css, 'a.comment_info_button')
+                                    reply_button.click
+                                    sleep(1.5)
+
+                                    textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                                    textarea.send_keys(content)
+                                    sleep(1)
+
+                                    if option['이모티콘자동삽입'] == 'true'
+                                        puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                        reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                        reply_comments.each_with_index do |item, index|
+                                            begin
+                                            
+                                                
+                                                # 해당 대댓글 내부의 이모티콘 버튼 찾기
+                                                sticker_button = item.find_element(:css, 'a.button_sticker')
+                                                sticker_button.click
+                                                sleep(1)
+                                                
+                                            rescue
+                                            end
+                                        end
+
+                                        begin
+                                            # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                                            sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                                                
+                                            # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                                            random_li = sticker_list_elements.sample
+                                            random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                                            random_button.click
+                                                                
+                                            sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                            # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                                            inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                                                
+                                            # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                                            random_button_in_li = inner_buttons.sample
+                                            sleep(1)
+                                            random_button_in_li.click
+                                                                
+                                            sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                            rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                                            #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                                            # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                                            # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+
+                                        rescue => e
+                                            puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                            # 기타 오류 처리
+                                            # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                                        end
+                                    else
+                                    puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                                    end
+                                
+                                    # 이미지 자동 삽입
+                                    if option['이미지자동삽입'] == 'true'
+                                        puts "이미지 자동 상입 옵션 진행!!".cyan
+                                                
+                                        # 아이프레임 요소가 나타날 때까지 기다립니다.
+                                        @image = image
+                                        image_path = image  
+                                        reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+
+                                        reply_comments.each_with_index do |item, index|
+                                            begin
+                                                
+
+                                                # 해당 대댓글 내부에서 for="attach2"인 라벨 클릭
+                                                attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                                attach_button.click
+                                                sleep(1)
+
+                                            rescue
+                                            end
+                                        end
+                                        key_stroke('escape')  
+                                        # 파일 경로 자동 입력
+                                        file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                                
+                                        # send_keys로 파일 경로를 입력하여 이미지 업로드
+                                        file_input.send_keys(image_path)
+                                        sleep(2)    
+                                                    
+                                    else
+                                    end
+
+                                    register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                                    register_btn.click
+                                    sleep(2)
+
+                                    puts "#{index + 1}번째 댓글에 대댓글 작성 완료"
+                                    rescue => e
+                                    puts "댓글 인덱스 #{index + 1} 처리 중 오류 발생: #{e.message}"
+                                    end
+                                else
+                                    puts "해당 인덱스(#{index + 1})의 답글쓰기 버튼이 없습니다."
+                                end
+
+                            else  # 닉네임으로 찾기
+                                comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                                original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                                matched = false
+                                last_matched_item = nil  # 마지막에 닉네임이 일치한 댓글 저장
+
+                                original_comments.each_with_index do |item, idx|
+                                begin
+                                    nickname_element = item.find_element(:css, 'a.comment_nickname')
+                                    nickname = nickname_element.text.strip
+
+                                    if nickname.include?(target)
+                                    puts "#{target} 닉네임이 포함된 댓글 발견 (#{idx + 1}번째)"
+                                    last_matched_item = item  # 매번 갱신 → 마지막에 발견된 걸 저장
+                                    end
+                                rescue => e
+                                    puts "닉네임 검사 중 오류 발생: #{e.message}"
+                                    next
+                                end
+                                end
+
+                                # 루프 끝난 뒤 마지막 댓글에만 작업 실행
+                                if last_matched_item
+                                begin
+
+                                    if @data['포스트설정']['순서사용2'].checked?
+                                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                            content = ''
+                                        else
+                                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                                content = @data['내용설정']['내용'].sample[2]
+                                            else
+                                                content = @data['내용설정']['내용'][@content_soon][2]
+                                                @content_soon += 1
+                                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                            end
+                                        end
+                                    else 
+                                    end 
+                                            
+                                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                                    if @data['포스트설정']['내용자동변경'].checked?
+                                        change_memory = {}
+                                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                        change_memory[key] = v.sample
+                                        end
+                                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                            if content.include?(key)
+                                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                            else
+                                            end
+                                        end
+                                    end    
+
+                                    if option['ChatGPT사용'] == 'true'
+                                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                            sleep(1)
+                                        
+                                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                                            @api_key = api_key
+                                            url = 'https://api.openai.com/v1/chat/completions'
+                                            headers = {
+                                            'Content-Type' => 'application/json',
+                                            'Authorization' => 'Bearer ' + @api_key
+                                            }
+                                            data = {
+                                            'model' => 'gpt-3.5-turbo',
+                                            'messages' => [
+                                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                            ]
+                                            }
+                                        
+                                            begin
+                                            req = HTTP.headers(headers).post(url, json: data)
+                                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                            response = JSON.parse(req.body.to_s)
+                                            puts "API Response: #{response}" # 전체 응답 출력
+                                        
+                                            if req.status == 429
+                                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                            end
+                                        
+                                            # 응답 데이터에서 안전하게 값 추출
+                                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                        
+                                            rescue => e
+                                            puts "Error: #{e.message}"
+                                            content = "오류가 발생했습니다."
+                                            end
+                                    else
+                                    end 
+
+                                    reply_button = last_matched_item.find_element(:css, 'a.comment_info_button')
+                                    reply_button.click
+                                    sleep(1.5)
+
+                                    textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                                    textarea.send_keys(content)
+                                    sleep(1)
+
+                                    if option['이모티콘자동삽입'] == 'true'
+                                    puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                    reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                    reply_comments.each_with_index do |item, index|
+                                        begin
+                                        
+                                        sticker_button = item.find_element(:css, 'a.button_sticker')
+                                        sticker_button.click
+                                        sleep(1)
+                                        rescue
+                                        end
+                                    end
+                                    begin
+                                        sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                        random_li = sticker_list_elements.sample
+                                        random_button = random_li.find_element(:tag_name, 'button')
+                                        random_button.click
+                                        sleep(1)
+                                        inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                        random_button_in_li = inner_buttons.sample
+                                        sleep(1)
+                                        random_button_in_li.click
+                                        sleep(1)
+                                    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+                                    rescue => e
+                                        puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                    end
+                                    else
+                                    puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                                    end
+
+                                    if option['이미지자동삽입'] == 'true'
+                                    puts "이미지 자동 삽입 옵션 진행!!".cyan
+                                    @image = image
+                                    image_path = image
+                                    reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                    reply_comments.each_with_index do |item, index|
+                                        begin
+                                        
+                                        attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                        attach_button.click
+                                        sleep(1)
+                                        rescue
+                                        end
+                                    end
+                                    key_stroke('escape')
+                                    file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                    file_input.send_keys(image_path)
+                                    sleep(2)
+                                    end
+
+                                    register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                                    register_btn.click
+                                    sleep(2)
+
+                                    matched = true
+                                rescue => e
+                                    puts "대댓글 등록 중 오류 발생: #{e.message}"
+                                end
+                            end
+
+                            puts "닉네임 '#{target}'을 포함한 댓글을 찾지 못했습니다." unless matched
+
+                        end
+                    end
+
+                 end    
+
+                elsif option['re_coment'] == 'false' # 대 댓글 아닐때 
+                    if @data['포스트설정']['순서사용2'].checked?
+                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                            content = ''
+                        else
+                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                content = @data['내용설정']['내용'].sample[2]
+                            else
+                                content = @data['내용설정']['내용'][@content_soon][2]
+                                @content_soon += 1
+                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                            end
+                        end
+                    else 
+                    end 
+                            
+                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                    if @data['포스트설정']['내용자동변경'].checked?
+                        change_memory = {}
+                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                        change_memory[key] = v.sample
+                        end
+                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                            if content.include?(key)
+                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                            else
+                            end
+                        end
+                    end    
+
+                    if option['ChatGPT사용'] == 'true'
+                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                            sleep(1)
+                        
+                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                            @api_key = api_key
+                            url = 'https://api.openai.com/v1/chat/completions'
+                            headers = {
+                            'Content-Type' => 'application/json',
+                            'Authorization' => 'Bearer ' + @api_key
+                            }
+                            data = {
+                            'model' => 'gpt-3.5-turbo',
+                            'messages' => [
+                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                            ]
+                            }
+                        
+                            begin
+                            req = HTTP.headers(headers).post(url, json: data)
+                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                            response = JSON.parse(req.body.to_s)
+                            puts "API Response: #{response}" # 전체 응답 출력
+                        
+                            if req.status == 429
+                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                            end
+                        
+                            # 응답 데이터에서 안전하게 값 추출
+                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                        
+                            rescue => e
+                            puts "Error: #{e.message}"
+                            content = "오류가 발생했습니다."
+                            end
+                    else
+                    end 
+
+                    wait = Selenium::WebDriver::Wait.new(timeout: 10)
+                    wait.until { @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]') }
+
+                    element = @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]')
+                    @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)
+                    sleep(1)
+
+                    element.send_keys(content)
+                    sleep(1)
+
+                    # 이모티콘 자동 삽입
+                    if option['이모티콘자동삽입'] == 'true'
+                        puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                        
+                        # '이모티콘' 버튼 클릭
+                        @driver.find_element(:xpath, '//*[@class="button_sticker"]').click
+                        sleep(1)
+                        
+                        begin
+                        # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                        sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                        
+                        # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                        random_li = sticker_list_elements.sample
+                        random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                        random_button.click
+                        
+                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+                            
+                        # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                        inner_buttons = random_li.find_elements(:tag_name, 'button')
+                        
+                        # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                        random_button_in_li = inner_buttons.sample
+                        sleep(1)
+                        random_button_in_li.click
+                        
+                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+                            
+                        rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                        #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                        # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                        # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+                            
+                        rescue => e
+                        puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                        # 기타 오류 처리
+                        # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                        end
+                    else
+                        puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                    end
+            
+                    # 이미지 자동 삽입
+                    if option['이미지자동삽입'] == 'true'
+                        puts "이미지 자동 상입 옵션 진행!!".cyan
+            
+                        # 아이프레임 요소가 나타날 때까지 기다립니다.
+                        @image = image
+                        image_path = image  
+                    
+                        @driver.find_element(:xpath, '//*[@for="attach2"]').click
+                        sleep(1)
+                        key_stroke('escape')  
+                        # 파일 경로 자동 입력
+                        file_input = @driver.find_element(:xpath, '//*[@class="button_file"]')
+            
+                        # send_keys로 파일 경로를 입력하여 이미지 업로드
+                        file_input.send_keys(image_path)
+                        sleep(2)    
                     
+                    else
+                    end
+
+                    
+                    wait.until { @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]') }
+                    @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]').click
+                    puts "#{board_url} [댓글 작성 완료 !!]".cyan
+                    sleep(2)
+                end
+
+           
+
+                begin
+                    @driver.switch_to.alert
+                    sleep(1)
+                    error_text = @driver.switch_to.alert.text
+                    sleep(1)
+                    @driver.switch_to.alert.accept
+                    puts (error_text).red
+                    posting_url = @driver.current_url
+                    
+                    File.open('./log/posting_log.txt', 'a') do |ff|
+                    ff.write('[')   
+                    ff.write(DateTime.now.strftime("%Y년%m월%d일%H시%M분"))
+                    ff.write(']')  
+                    ff.write('　') 
+                    ff.write('【등록실패:')     
+                    ff.write(error_text)
+                    ff.write('】')
+                    ff.write('　')
+                    ff.write(posting_url)
+                    ff.close()
+                    puts '-[√] 로그 파일 생성 완료.......'.yellow     
+                    end   
+            
+                rescue
+                    #@driver.execute_script("document.body.style.zoom = '1.00'") 
+                    sleep(1)
+                    posting_url = @driver.current_url
+                    
+                    File.open('./log/posting_log.txt', 'a') do |ff|
+                    ff.write('[')   
+                    ff.write(DateTime.now.strftime("%Y년%m월%d일%H시%M분"))
+                    ff.write(']')  
+                    ff.write('　')  
+                    ff.write('【등록성공확인】') 
+                    ff.write('　')  
+                    ff.write(posting_url)
+                    ff.write("\n")
+                    ff.close()
+                    puts '-[√] 로그 파일 생성 완료.......'.yellow   
+                    end 
+                end         
+                
+                @driver.switch_to.default_content()                                              # 아이프레임 해제
+                def sleep_with_progress(sleep_delay)
+                    print "[설정 딜레이 진행 중] "
+                    steps = (sleep_delay.to_f / 0.5).to_i
+                    steps.times do
+                        print "."
+                        STDOUT.flush
+                        sleep(1)
+                    end
+                    puts "\n"
+                end
+
+                sleep_with_progress(sleep_delay)
+                
+
+            rescue => e
+                puts "Error: #{e.message}"
+            end  
+        end
+        else
+        end
+    
+        ################################################################################ 설정게시글사용 ################################################################################
+
+        if option['설정게시글사용'] == 'true'
+            puts "게시판 list 기반으로 댓글 작업 옵션 진행!!".cyan
+        
+                @driver.get(board_url)  # 해당 URL로 이동
+                begin
+                    # 아이프레임 요소가 나타날 때까지 기다립니다.
+                    wait = Selenium::WebDriver::Wait.new(:timeout => 20)                            # 아이프레임 선택
+                    wait.until { @driver.find_element(:xpath, '//*[@id="cafe_main"]') }             # 아이프레임 선택
+                    sleep(1)
+                    @driver.switch_to.frame(@driver.find_element(:xpath, '//*[@id="cafe_main"]'))   # 아이프레임 선택
+        
+                
+                    if option['좋아요'] == 'true'
+                        puts "좋아요 클릭 옵션 진행!!".cyan
+                        wait = Selenium::WebDriver::Wait.new(:timeout => 10)
+                        wait.until { @driver.find_element(:xpath, '//*[@class="u_ico _icon"]') }
+            
+                        # 댓글 입력
+                        element = @driver.find_element(:xpath, '//*[@class="u_ico _icon"]')
+                        @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)#크롤 이동
+                        sleep(1)
+            
+                        # 좋아요 버튼을 찾기
+                        like_button = @driver.find_element(:xpath, '//div[@class="ReactionLikeIt u_likeit_list_module _cafeReactionModule"]//a[@role="button"]')
+            
+                        # aria-pressed 속성 값 확인
+                        aria_pressed = like_button.attribute('aria-pressed')
+            
+                        if aria_pressed == 'true'
+                        # 이미 좋아요를 누른 상태일 경우
+                        
+                        else
+                        # 좋아요를 아직 누르지 않은 상태일 경우 클릭
+                        @driver.find_element(:xpath, '//*[@class="u_ico _icon"]').click
+                        sleep(2)
+                        end
+                    else
+                    end    
+
+                  
+                  
+            if option['re_coment'] == 'true' # 대 댓글 작업때
+                if @data['포스트설정']['전체대댓글'].checked?
+                    begin
+                        comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                        original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                        original_comments.each_with_index do |item, index|
+
+                        begin
+
+                            if @data['포스트설정']['순서사용2'].checked?
+                                @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                    content = ''
+                                else
+                                    if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                        content = @data['내용설정']['내용'].sample[2]
+                                    else
+                                        content = @data['내용설정']['내용'][@content_soon][2]
+                                        @content_soon += 1
+                                        @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                    end
+                                end
+                            else 
+                            end 
+                                    
+                            # 디엠 자동 변경이 체크된 경우 content를 변환
+                            if @data['포스트설정']['내용자동변경'].checked?
+                                change_memory = {}
+                                @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                change_memory[key] = v.sample
+                                end
+                                @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                    if content.include?(key)
+                                    content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                    else
+                                    end
+                                end
+                            end    
+
+                            if option['ChatGPT사용'] == 'true'
+                                    pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                    sleep(1)
+                                
+                                    puts "ChatGPT로 댓글을 만드는 중입니다."
+                                    @api_key = api_key
+                                    url = 'https://api.openai.com/v1/chat/completions'
+                                    headers = {
+                                    'Content-Type' => 'application/json',
+                                    'Authorization' => 'Bearer ' + @api_key
+                                    }
+                                    data = {
+                                    'model' => 'gpt-3.5-turbo',
+                                    'messages' => [
+                                        { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                        { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                    ]
+                                    }
+                                
+                                    begin
+                                    req = HTTP.headers(headers).post(url, json: data)
+                                    puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                    response = JSON.parse(req.body.to_s)
+                                    puts "API Response: #{response}" # 전체 응답 출력
+                                
+                                    if req.status == 429
+                                        return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                    end
+                                
+                                    # 응답 데이터에서 안전하게 값 추출
+                                    raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                    content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                
+                                    rescue => e
+                                    puts "Error: #{e.message}"
+                                    content = "오류가 발생했습니다."
+                                    end
+                            else
+                            end 
+
+                            reply_button = item.find_element(:css, 'a.comment_info_button')
+                            puts "대댓글 #{index + 1} 작성 중..."
+                            reply_button.click
+                            sleep(1.5)
+
+                            textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                            textarea.send_keys(content)
+                            sleep(1)
+
+                            if option['이모티콘자동삽입'] == 'true'
+                                puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                reply_comments.each_with_index do |item, index|
+                                    begin
+                                        
+                                        
+                                        # 해당 대댓글 내부의 이모티콘 버튼 찾기
+                                        sticker_button = item.find_element(:css, 'a.button_sticker')
+                                        sticker_button.click
+                                        sleep(1)
+                                        
+                                    rescue
+                                    end
+                                end
+                                begin
+                                # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                                sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                                    
+                                # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                                random_li = sticker_list_elements.sample
+                                random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                                random_button.click
+                                                    
+                                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                                inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                                    
+                                # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                                random_button_in_li = inner_buttons.sample
+                                sleep(1)
+                                random_button_in_li.click
+                                                    
+                                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                                #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                                # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                                # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+
+                                rescue => e
+                                puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                # 기타 오류 처리
+                                # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                                end
+                            else
+                                puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                            end
+        
+                            # 이미지 자동 삽입
+                            if option['이미지자동삽입'] == 'true'
+                                puts "이미지 자동 상입 옵션 진행!!".cyan
+                                        
+                                # 아이프레임 요소가 나타날 때까지 기다립니다.
+                                @image = image
+                                image_path = image  
+                                reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+
+                                reply_comments.each_with_index do |item, index|
+                                    begin
+                                        
+
+                                        # 해당 대댓글 내부에서 for="attach2"인 라벨 클릭
+                                        attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                        attach_button.click
+                                        sleep(1)
+
+                                    rescue
+                                    end
+                                end
+                                key_stroke('escape')  
+                                # 파일 경로 자동 입력
+                                file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                        
+                                # send_keys로 파일 경로를 입력하여 이미지 업로드
+                                file_input.send_keys(image_path)
+                                sleep(2)    
+                        
+                            else
+                            end
+
+                            register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                            register_btn.click
+                            sleep(2)
+
+                        rescue => e
+                            puts "대댓글 #{index + 1} 처리 중 오류 발생: #{e.message}"
+                            next
+                            end
+                        end
+                    rescue => e
+                        puts "전체대댓글 처리 중 예외 발생: #{e.message}"
+                    end
+
+                elsif @data['포스트설정']['지정대댓글'].checked? 
+                    targets = @data['포스트설정']['nik_or_number'].text.to_s.force_encoding('utf-8').split(',').map(&:strip)
+                    targets.each do |target|
+                        if target.match?(/^\d+$/)
+                            index = target.to_i - 1
+                            comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                            original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                            if original_comments[index]
+                                begin
+
+                                    if @data['포스트설정']['순서사용2'].checked?
+                                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                            content = ''
+                                        else
+                                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                                content = @data['내용설정']['내용'].sample[2]
+                                            else
+                                                content = @data['내용설정']['내용'][@content_soon][2]
+                                                @content_soon += 1
+                                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                            end
+                                        end
+                                    else 
+                                    end 
+                                            
+                                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                                    if @data['포스트설정']['내용자동변경'].checked?
+                                        change_memory = {}
+                                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                        change_memory[key] = v.sample
+                                        end
+                                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                            if content.include?(key)
+                                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                            else
+                                            end
+                                        end
+                                    end    
+
+                                    if option['ChatGPT사용'] == 'true'
+                                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                            sleep(1)
+                                        
+                                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                                            @api_key = api_key
+                                            url = 'https://api.openai.com/v1/chat/completions'
+                                            headers = {
+                                            'Content-Type' => 'application/json',
+                                            'Authorization' => 'Bearer ' + @api_key
+                                            }
+                                            data = {
+                                            'model' => 'gpt-3.5-turbo',
+                                            'messages' => [
+                                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                            ]
+                                            }
+                                        
+                                            begin
+                                            req = HTTP.headers(headers).post(url, json: data)
+                                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                            response = JSON.parse(req.body.to_s)
+                                            puts "API Response: #{response}" # 전체 응답 출력
+                                        
+                                            if req.status == 429
+                                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                            end
+                                        
+                                            # 응답 데이터에서 안전하게 값 추출
+                                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                        
+                                            rescue => e
+                                            puts "Error: #{e.message}"
+                                            content = "오류가 발생했습니다."
+                                            end
+                                    else
+                                    end 
+
+                                    puts "#{index + 1}번째 댓글에 대댓글 작성 시작"
+                                    reply_button = original_comments[index].find_element(:css, 'a.comment_info_button')
+                                    reply_button.click
+                                    sleep(1.5)
+
+                                    textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                                    textarea.send_keys(content)
+                                    sleep(1)
+
+                                    if option['이모티콘자동삽입'] == 'true'
+                                        puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                        reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                        reply_comments.each_with_index do |item, index|
+                                            begin
+                                            
+                                                
+                                                # 해당 대댓글 내부의 이모티콘 버튼 찾기
+                                                sticker_button = item.find_element(:css, 'a.button_sticker')
+                                                sticker_button.click
+                                                sleep(1)
+                                                
+                                            rescue
+                                            end
+                                        end
+
+                                        begin
+                                            # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                                            sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                                                
+                                            # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                                            random_li = sticker_list_elements.sample
+                                            random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                                            random_button.click
+                                                                
+                                            sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                            # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                                            inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                                                
+                                            # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                                            random_button_in_li = inner_buttons.sample
+                                            sleep(1)
+                                            random_button_in_li.click
+                                                                
+                                            sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                            rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                                            #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                                            # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                                            # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+
+                                        rescue => e
+                                            puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                            # 기타 오류 처리
+                                            # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                                        end
+                                    else
+                                    puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                                    end
+                                
+                                    # 이미지 자동 삽입
+                                    if option['이미지자동삽입'] == 'true'
+                                        puts "이미지 자동 상입 옵션 진행!!".cyan
+                                                
+                                        # 아이프레임 요소가 나타날 때까지 기다립니다.
+                                        @image = image
+                                        image_path = image  
+                                        reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+
+                                        reply_comments.each_with_index do |item, index|
+                                            begin
+                                                
+
+                                                # 해당 대댓글 내부에서 for="attach2"인 라벨 클릭
+                                                attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                                attach_button.click
+                                                sleep(1)
+
+                                            rescue
+                                            end
+                                        end
+                                        key_stroke('escape')  
+                                        # 파일 경로 자동 입력
+                                        file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                                
+                                        # send_keys로 파일 경로를 입력하여 이미지 업로드
+                                        file_input.send_keys(image_path)
+                                        sleep(2)    
+                                                    
+                                    else
+                                    end
+
+                                    register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                                    register_btn.click
+                                    sleep(2)
+
+                                    puts "#{index + 1}번째 댓글에 대댓글 작성 완료"
+                                    rescue => e
+                                    puts "댓글 인덱스 #{index + 1} 처리 중 오류 발생: #{e.message}"
+                                    end
+                                else
+                                    puts "해당 인덱스(#{index + 1})의 답글쓰기 버튼이 없습니다."
+                                end
+
+                            else  # 닉네임으로 찾기
+                                comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                                original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                                matched = false
+                                last_matched_item = nil  # 마지막에 닉네임이 일치한 댓글 저장
+
+                                original_comments.each_with_index do |item, idx|
+                                begin
+                                    nickname_element = item.find_element(:css, 'a.comment_nickname')
+                                    nickname = nickname_element.text.strip
+
+                                    if nickname.include?(target)
+                                    puts "#{target} 닉네임이 포함된 댓글 발견 (#{idx + 1}번째)"
+                                    last_matched_item = item  # 매번 갱신 → 마지막에 발견된 걸 저장
+                                    end
+                                rescue => e
+                                    puts "닉네임 검사 중 오류 발생: #{e.message}"
+                                    next
+                                end
+                                end
+
+                                # 루프 끝난 뒤 마지막 댓글에만 작업 실행
+                                if last_matched_item
+                                begin
+
+                                    if @data['포스트설정']['순서사용2'].checked?
+                                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                            content = ''
+                                        else
+                                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                                content = @data['내용설정']['내용'].sample[2]
+                                            else
+                                                content = @data['내용설정']['내용'][@content_soon][2]
+                                                @content_soon += 1
+                                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                            end
+                                        end
+                                    else 
+                                    end 
+                                            
+                                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                                    if @data['포스트설정']['내용자동변경'].checked?
+                                        change_memory = {}
+                                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                        change_memory[key] = v.sample
+                                        end
+                                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                            if content.include?(key)
+                                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                            else
+                                            end
+                                        end
+                                    end    
+
+                                    if option['ChatGPT사용'] == 'true'
+                                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                            sleep(1)
+                                        
+                                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                                            @api_key = api_key
+                                            url = 'https://api.openai.com/v1/chat/completions'
+                                            headers = {
+                                            'Content-Type' => 'application/json',
+                                            'Authorization' => 'Bearer ' + @api_key
+                                            }
+                                            data = {
+                                            'model' => 'gpt-3.5-turbo',
+                                            'messages' => [
+                                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                            ]
+                                            }
+                                        
+                                            begin
+                                            req = HTTP.headers(headers).post(url, json: data)
+                                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                            response = JSON.parse(req.body.to_s)
+                                            puts "API Response: #{response}" # 전체 응답 출력
+                                        
+                                            if req.status == 429
+                                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                            end
+                                        
+                                            # 응답 데이터에서 안전하게 값 추출
+                                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                        
+                                            rescue => e
+                                            puts "Error: #{e.message}"
+                                            content = "오류가 발생했습니다."
+                                            end
+                                    else
+                                    end 
+
+                                    reply_button = last_matched_item.find_element(:css, 'a.comment_info_button')
+                                    reply_button.click
+                                    sleep(1.5)
+
+                                    textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                                    textarea.send_keys(content)
+                                    sleep(1)
+
+                                    if option['이모티콘자동삽입'] == 'true'
+                                    puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                    reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                    reply_comments.each_with_index do |item, index|
+                                        begin
+                                        
+                                        sticker_button = item.find_element(:css, 'a.button_sticker')
+                                        sticker_button.click
+                                        sleep(1)
+                                        rescue
+                                        end
+                                    end
+                                    begin
+                                        sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                        random_li = sticker_list_elements.sample
+                                        random_button = random_li.find_element(:tag_name, 'button')
+                                        random_button.click
+                                        sleep(1)
+                                        inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                        random_button_in_li = inner_buttons.sample
+                                        sleep(1)
+                                        random_button_in_li.click
+                                        sleep(1)
+                                    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+                                    rescue => e
+                                        puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                    end
+                                    else
+                                    puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                                    end
+
+                                    if option['이미지자동삽입'] == 'true'
+                                    puts "이미지 자동 삽입 옵션 진행!!".cyan
+                                    @image = image
+                                    image_path = image
+                                    reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                    reply_comments.each_with_index do |item, index|
+                                        begin
+                                        
+                                        attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                        attach_button.click
+                                        sleep(1)
+                                        rescue
+                                        end
+                                    end
+                                    key_stroke('escape')
+                                    file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                    file_input.send_keys(image_path)
+                                    sleep(2)
+                                    end
+
+                                    register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                                    register_btn.click
+                                    sleep(2)
+
+                                    matched = true
+                                rescue => e
+                                    puts "대댓글 등록 중 오류 발생: #{e.message}"
+                                end
+                            end
+
+                            puts "닉네임 '#{target}'을 포함한 댓글을 찾지 못했습니다." unless matched
+
+                        end
+                    end
+
+                 end    
+
+                elsif option['re_coment'] == 'false' # 대 댓글 아닐때 
+                    if @data['포스트설정']['순서사용2'].checked?
+                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                            content = ''
+                        else
+                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                content = @data['내용설정']['내용'].sample[2]
+                            else
+                                content = @data['내용설정']['내용'][@content_soon][2]
+                                @content_soon += 1
+                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                            end
+                        end
+                    else 
+                    end 
+                            
+                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                    if @data['포스트설정']['내용자동변경'].checked?
+                        change_memory = {}
+                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                        change_memory[key] = v.sample
+                        end
+                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                            if content.include?(key)
+                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                            else
+                            end
+                        end
+                    end    
+
+                    if option['ChatGPT사용'] == 'true'
+                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                            sleep(1)
+                        
+                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                            @api_key = api_key
+                            url = 'https://api.openai.com/v1/chat/completions'
+                            headers = {
+                            'Content-Type' => 'application/json',
+                            'Authorization' => 'Bearer ' + @api_key
+                            }
+                            data = {
+                            'model' => 'gpt-3.5-turbo',
+                            'messages' => [
+                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                            ]
+                            }
+                        
+                            begin
+                            req = HTTP.headers(headers).post(url, json: data)
+                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                            response = JSON.parse(req.body.to_s)
+                            puts "API Response: #{response}" # 전체 응답 출력
+                        
+                            if req.status == 429
+                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                            end
+                        
+                            # 응답 데이터에서 안전하게 값 추출
+                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                        
+                            rescue => e
+                            puts "Error: #{e.message}"
+                            content = "오류가 발생했습니다."
+                            end
+                    else
+                    end 
+
+                    wait = Selenium::WebDriver::Wait.new(timeout: 10)
+                    wait.until { @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]') }
+
+                    element = @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]')
+                    @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)
+                    sleep(1)
+
+                    element.send_keys(content)
+                    sleep(1)
+
+                    # 이모티콘 자동 삽입
+                    if option['이모티콘자동삽입'] == 'true'
+                        puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                        
                         # '이모티콘' 버튼 클릭
                         @driver.find_element(:xpath, '//*[@class="button_sticker"]').click
                         sleep(1)
-                    
+                        
                         begin
                         # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
                         sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
-                    
+                        
                         # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
                         random_li = sticker_list_elements.sample
                         random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
                         random_button.click
-                    
-                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
                         
+                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+                            
                         # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
                         inner_buttons = random_li.find_elements(:tag_name, 'button')
-                    
+                        
                         # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
                         random_button_in_li = inner_buttons.sample
                         sleep(1)
                         random_button_in_li.click
-                    
-                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
                         
+                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+                            
                         rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
                         #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
                         # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
                         # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
-                        
+                            
                         rescue => e
                         puts "기타 오류로 인해 이모티콘 삽입 안됨"
                         # 기타 오류 처리
@@ -916,34 +2008,37 @@ class Naver
                     else
                         puts "이모티콘 자동 삽입 옵션이 비활성화됨."
                     end
-        
+            
                     # 이미지 자동 삽입
                     if option['이미지자동삽입'] == 'true'
-                    puts "이미지 자동 상입 옵션 진행!!".cyan
-    
-                    # 아이프레임 요소가 나타날 때까지 기다립니다.
-                    @image = image
-                    image_path = image  
-              
-                    @driver.find_element(:xpath, '//*[@for="attach2"]').click
-                    sleep(1)
-                    key_stroke('escape')  
-                    # 파일 경로 자동 입력
-                    file_input = @driver.find_element(:xpath, '//*[@id="attach2"]')
-    
-                    # send_keys로 파일 경로를 입력하여 이미지 업로드
-                    file_input.send_keys(image_path)
-                    sleep(2)    
-               
+                        puts "이미지 자동 상입 옵션 진행!!".cyan
+            
+                        # 아이프레임 요소가 나타날 때까지 기다립니다.
+                        @image = image
+                        image_path = image  
+                    
+                        @driver.find_element(:xpath, '//*[@for="attach2"]').click
+                        sleep(1)
+                        key_stroke('escape')  
+                        # 파일 경로 자동 입력
+                        file_input = @driver.find_element(:xpath, '//*[@class="button_file"]')
+            
+                        # send_keys로 파일 경로를 입력하여 이미지 업로드
+                        file_input.send_keys(image_path)
+                        sleep(2)    
+                    
                     else
                     end
 
-                
+                    
                     wait.until { @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]') }
                     @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]').click
                     puts "#{board_url} [댓글 작성 완료 !!]".cyan
-                
                     sleep(2)
+                end
+
+           
+
                 begin
                     @driver.switch_to.alert
                     sleep(1)
@@ -984,28 +2079,28 @@ class Naver
                     ff.close()
                     puts '-[√] 로그 파일 생성 완료.......'.yellow   
                     end 
-                end 
-                end
-                    @driver.switch_to.default_content()                                              # 아이프레임 해제
-                    def sleep_with_progress(sleep_delay)
-                        print "[설정 딜레이 진행 중] "
-                        steps = (sleep_delay.to_f / 0.5).to_i
-                        steps.times do
-                            print "."
-                            STDOUT.flush
-                            sleep(1)
-                        end
-                        puts "\n"
+                end         
+                
+                @driver.switch_to.default_content()                                              # 아이프레임 해제
+                def sleep_with_progress(sleep_delay)
+                    print "[설정 딜레이 진행 중] "
+                    steps = (sleep_delay.to_f / 0.5).to_i
+                    steps.times do
+                        print "."
+                        STDOUT.flush
+                        sleep(1)
                     end
-                    sleep_with_progress(sleep_delay)
-                   
+                    puts "\n"
+                end
 
-                rescue => e
-                    puts "Error: #{e.message}"
-                end  
-            
-            else
-            end
+                sleep_with_progress(sleep_delay)
+                
+
+            rescue => e
+                puts "Error: #{e.message}"
+            end  
+        else
+        end
         ################################################################################ 키워드검색사용 ################################################################################  
         if option['키워드검색사용'] == 'true'
         puts "키워드 검색 기반으로 댓글 작업 옵션 진행!!".cyan
@@ -1097,203 +2192,744 @@ class Naver
         puts "수집한 URL들: #{collected_urls}"
 
 
-        collected_urls.first(counts_number).each do |url|
-        @driver.get(url)  # 해당 URL로 이동
-        sleep(1)
-        wait = Selenium::WebDriver::Wait.new(:timeout => 20)                            # 아이프레임 선택
-        wait.until { @driver.find_element(:xpath, '//*[@id="cafe_main"]') }             # 아이프레임 선택
-        sleep(1)
-        @driver.switch_to.frame(@driver.find_element(:xpath, '//*[@id="cafe_main"]'))   # 아이프레임 선택
+        collected_urls.first(counts_number).each do |url|
+        @driver.get(url)  # 해당 URL로 이동
+        sleep(1)
+        wait = Selenium::WebDriver::Wait.new(:timeout => 20)                            # 아이프레임 선택
+        wait.until { @driver.find_element(:xpath, '//*[@id="cafe_main"]') }             # 아이프레임 선택
+        sleep(1)
+        @driver.switch_to.frame(@driver.find_element(:xpath, '//*[@id="cafe_main"]'))   # 아이프레임 선택
+
+        
+        if option['좋아요'] == 'true'
+            puts "좋아요 클릭 옵션 진행!!".cyan
+            wait = Selenium::WebDriver::Wait.new(:timeout => 10)
+            wait.until { @driver.find_element(:xpath, '//*[@class="u_ico _icon"]') }
+            
+            # 댓글 입력
+            element = @driver.find_element(:xpath, '//*[@class="u_ico _icon"]')
+            @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)#크롤 이동
+            sleep(1)
+            
+            # 좋아요 버튼을 찾기
+            like_button = @driver.find_element(:xpath, '//div[@class="ReactionLikeIt u_likeit_list_module _cafeReactionModule"]//a[@role="button"]')
+            
+            # aria-pressed 속성 값 확인
+            aria_pressed = like_button.attribute('aria-pressed')
+            
+            if aria_pressed == 'true'
+            # 이미 좋아요를 누른 상태일 경우
+                        
+            else
+            # 좋아요를 아직 누르지 않은 상태일 경우 클릭
+            @driver.find_element(:xpath, '//*[@class="u_ico _icon"]').click
+            sleep(2)
+            end
+        else
+        end    
+
+                  
+                  
+            if option['re_coment'] == 'true' # 대 댓글 작업때
+                if @data['포스트설정']['전체대댓글'].checked?
+                    begin
+                        comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                        original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                        original_comments.each_with_index do |item, index|
+
+                        begin
+
+                            if @data['포스트설정']['순서사용2'].checked?
+                                @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                    content = ''
+                                else
+                                    if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                        content = @data['내용설정']['내용'].sample[2]
+                                    else
+                                        content = @data['내용설정']['내용'][@content_soon][2]
+                                        @content_soon += 1
+                                        @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                    end
+                                end
+                            else 
+                            end 
+                                    
+                            # 디엠 자동 변경이 체크된 경우 content를 변환
+                            if @data['포스트설정']['내용자동변경'].checked?
+                                change_memory = {}
+                                @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                change_memory[key] = v.sample
+                                end
+                                @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                    if content.include?(key)
+                                    content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                    else
+                                    end
+                                end
+                            end    
+
+                            if option['ChatGPT사용'] == 'true'
+                                    pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                    sleep(1)
+                                
+                                    puts "ChatGPT로 댓글을 만드는 중입니다."
+                                    @api_key = api_key
+                                    url = 'https://api.openai.com/v1/chat/completions'
+                                    headers = {
+                                    'Content-Type' => 'application/json',
+                                    'Authorization' => 'Bearer ' + @api_key
+                                    }
+                                    data = {
+                                    'model' => 'gpt-3.5-turbo',
+                                    'messages' => [
+                                        { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                        { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                    ]
+                                    }
+                                
+                                    begin
+                                    req = HTTP.headers(headers).post(url, json: data)
+                                    puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                    response = JSON.parse(req.body.to_s)
+                                    puts "API Response: #{response}" # 전체 응답 출력
+                                
+                                    if req.status == 429
+                                        return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                    end
+                                
+                                    # 응답 데이터에서 안전하게 값 추출
+                                    raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                    content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                
+                                    rescue => e
+                                    puts "Error: #{e.message}"
+                                    content = "오류가 발생했습니다."
+                                    end
+                            else
+                            end 
+
+                            reply_button = item.find_element(:css, 'a.comment_info_button')
+                            puts "대댓글 #{index + 1} 작성 중..."
+                            reply_button.click
+                            sleep(1.5)
+
+                            textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                            textarea.send_keys(content)
+                            sleep(1)
+
+                            if option['이모티콘자동삽입'] == 'true'
+                                puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                reply_comments.each_with_index do |item, index|
+                                    begin
+                                        
+                                        
+                                        # 해당 대댓글 내부의 이모티콘 버튼 찾기
+                                        sticker_button = item.find_element(:css, 'a.button_sticker')
+                                        sticker_button.click
+                                        sleep(1)
+                                        
+                                    rescue
+                                    end
+                                end
+                                begin
+                                # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                                sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                                    
+                                # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                                random_li = sticker_list_elements.sample
+                                random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                                random_button.click
+                                                    
+                                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                                inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                                    
+                                # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                                random_button_in_li = inner_buttons.sample
+                                sleep(1)
+                                random_button_in_li.click
+                                                    
+                                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                                #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                                # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                                # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+
+                                rescue => e
+                                puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                # 기타 오류 처리
+                                # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                                end
+                            else
+                                puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                            end
+        
+                            # 이미지 자동 삽입
+                            if option['이미지자동삽입'] == 'true'
+                                puts "이미지 자동 상입 옵션 진행!!".cyan
+                                        
+                                # 아이프레임 요소가 나타날 때까지 기다립니다.
+                                @image = image
+                                image_path = image  
+                                reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+
+                                reply_comments.each_with_index do |item, index|
+                                    begin
+                                        
+
+                                        # 해당 대댓글 내부에서 for="attach2"인 라벨 클릭
+                                        attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                        attach_button.click
+                                        sleep(1)
+
+                                    rescue
+                                    end
+                                end
+                                key_stroke('escape')  
+                                # 파일 경로 자동 입력
+                                file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                        
+                                # send_keys로 파일 경로를 입력하여 이미지 업로드
+                                file_input.send_keys(image_path)
+                                sleep(2)    
+                        
+                            else
+                            end
+
+                            register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                            register_btn.click
+                            sleep(2)
+
+                        rescue => e
+                            puts "대댓글 #{index + 1} 처리 중 오류 발생: #{e.message}"
+                            next
+                            end
+                        end
+                    rescue => e
+                        puts "전체대댓글 처리 중 예외 발생: #{e.message}"
+                    end
+
+                elsif @data['포스트설정']['지정대댓글'].checked? 
+                    targets = @data['포스트설정']['nik_or_number'].text.to_s.force_encoding('utf-8').split(',').map(&:strip)
+                    targets.each do |target|
+                        if target.match?(/^\d+$/)
+                            index = target.to_i - 1
+                            comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                            original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                            if original_comments[index]
+                                begin
+
+                                    if @data['포스트설정']['순서사용2'].checked?
+                                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                            content = ''
+                                        else
+                                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                                content = @data['내용설정']['내용'].sample[2]
+                                            else
+                                                content = @data['내용설정']['내용'][@content_soon][2]
+                                                @content_soon += 1
+                                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                            end
+                                        end
+                                    else 
+                                    end 
+                                            
+                                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                                    if @data['포스트설정']['내용자동변경'].checked?
+                                        change_memory = {}
+                                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                        change_memory[key] = v.sample
+                                        end
+                                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                            if content.include?(key)
+                                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                            else
+                                            end
+                                        end
+                                    end    
+
+                                    if option['ChatGPT사용'] == 'true'
+                                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                            sleep(1)
+                                        
+                                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                                            @api_key = api_key
+                                            url = 'https://api.openai.com/v1/chat/completions'
+                                            headers = {
+                                            'Content-Type' => 'application/json',
+                                            'Authorization' => 'Bearer ' + @api_key
+                                            }
+                                            data = {
+                                            'model' => 'gpt-3.5-turbo',
+                                            'messages' => [
+                                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                            ]
+                                            }
+                                        
+                                            begin
+                                            req = HTTP.headers(headers).post(url, json: data)
+                                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                            response = JSON.parse(req.body.to_s)
+                                            puts "API Response: #{response}" # 전체 응답 출력
+                                        
+                                            if req.status == 429
+                                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                            end
+                                        
+                                            # 응답 데이터에서 안전하게 값 추출
+                                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                        
+                                            rescue => e
+                                            puts "Error: #{e.message}"
+                                            content = "오류가 발생했습니다."
+                                            end
+                                    else
+                                    end 
+
+                                    puts "#{index + 1}번째 댓글에 대댓글 작성 시작"
+                                    reply_button = original_comments[index].find_element(:css, 'a.comment_info_button')
+                                    reply_button.click
+                                    sleep(1.5)
+
+                                    textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                                    textarea.send_keys(content)
+                                    sleep(1)
+
+                                    if option['이모티콘자동삽입'] == 'true'
+                                        puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                        reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                        reply_comments.each_with_index do |item, index|
+                                            begin
+                                            
+                                                
+                                                # 해당 대댓글 내부의 이모티콘 버튼 찾기
+                                                sticker_button = item.find_element(:css, 'a.button_sticker')
+                                                sticker_button.click
+                                                sleep(1)
+                                                
+                                            rescue
+                                            end
+                                        end
+
+                                        begin
+                                            # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                                            sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                                                
+                                            # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                                            random_li = sticker_list_elements.sample
+                                            random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                                            random_button.click
+                                                                
+                                            sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                            # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                                            inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                                                
+                                            # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                                            random_button_in_li = inner_buttons.sample
+                                            sleep(1)
+                                            random_button_in_li.click
+                                                                
+                                            sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+
+                                            rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                                            #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                                            # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                                            # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+
+                                        rescue => e
+                                            puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                            # 기타 오류 처리
+                                            # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                                        end
+                                    else
+                                    puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                                    end
+                                
+                                    # 이미지 자동 삽입
+                                    if option['이미지자동삽입'] == 'true'
+                                        puts "이미지 자동 상입 옵션 진행!!".cyan
+                                                
+                                        # 아이프레임 요소가 나타날 때까지 기다립니다.
+                                        @image = image
+                                        image_path = image  
+                                        reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+
+                                        reply_comments.each_with_index do |item, index|
+                                            begin
+                                                
+
+                                                # 해당 대댓글 내부에서 for="attach2"인 라벨 클릭
+                                                attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                                attach_button.click
+                                                sleep(1)
+
+                                            rescue
+                                            end
+                                        end
+                                        key_stroke('escape')  
+                                        # 파일 경로 자동 입력
+                                        file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                                
+                                        # send_keys로 파일 경로를 입력하여 이미지 업로드
+                                        file_input.send_keys(image_path)
+                                        sleep(2)    
+                                                    
+                                    else
+                                    end
+
+                                    register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                                    register_btn.click
+                                    sleep(2)
+
+                                    puts "#{index + 1}번째 댓글에 대댓글 작성 완료"
+                                    rescue => e
+                                    puts "댓글 인덱스 #{index + 1} 처리 중 오류 발생: #{e.message}"
+                                    end
+                                else
+                                    puts "해당 인덱스(#{index + 1})의 답글쓰기 버튼이 없습니다."
+                                end
+
+                            else  # 닉네임으로 찾기
+                                comment_items = @driver.find_elements(:css, 'li.CommentItem')
+                                original_comments = comment_items.select { |item| !item.attribute('class').include?('CommentItem--reply') }
+
+                                matched = false
+                                last_matched_item = nil  # 마지막에 닉네임이 일치한 댓글 저장
+
+                                original_comments.each_with_index do |item, idx|
+                                begin
+                                    nickname_element = item.find_element(:css, 'a.comment_nickname')
+                                    nickname = nickname_element.text.strip
+
+                                    if nickname.include?(target)
+                                    puts "#{target} 닉네임이 포함된 댓글 발견 (#{idx + 1}번째)"
+                                    last_matched_item = item  # 매번 갱신 → 마지막에 발견된 걸 저장
+                                    end
+                                rescue => e
+                                    puts "닉네임 검사 중 오류 발생: #{e.message}"
+                                    next
+                                end
+                                end
+
+                                # 루프 끝난 뒤 마지막 댓글에만 작업 실행
+                                if last_matched_item
+                                begin
+
+                                    if @data['포스트설정']['순서사용2'].checked?
+                                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+
+                                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                                            content = ''
+                                        else
+                                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                                content = @data['내용설정']['내용'].sample[2]
+                                            else
+                                                content = @data['내용설정']['내용'][@content_soon][2]
+                                                @content_soon += 1
+                                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                                            end
+                                        end
+                                    else 
+                                    end 
+                                            
+                                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                                    if @data['포스트설정']['내용자동변경'].checked?
+                                        change_memory = {}
+                                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                                        change_memory[key] = v.sample
+                                        end
+                                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                                            if content.include?(key)
+                                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                                            else
+                                            end
+                                        end
+                                    end    
 
-        if @data['포스트설정']['순서사용2'].checked?
-            @content_soon ||= 0  # 초기 한 번만 0으로 세팅
+                                    if option['ChatGPT사용'] == 'true'
+                                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                                            sleep(1)
+                                        
+                                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                                            @api_key = api_key
+                                            url = 'https://api.openai.com/v1/chat/completions'
+                                            headers = {
+                                            'Content-Type' => 'application/json',
+                                            'Authorization' => 'Bearer ' + @api_key
+                                            }
+                                            data = {
+                                            'model' => 'gpt-3.5-turbo',
+                                            'messages' => [
+                                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                                            ]
+                                            }
+                                        
+                                            begin
+                                            req = HTTP.headers(headers).post(url, json: data)
+                                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                                            response = JSON.parse(req.body.to_s)
+                                            puts "API Response: #{response}" # 전체 응답 출력
+                                        
+                                            if req.status == 429
+                                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                                            end
+                                        
+                                            # 응답 데이터에서 안전하게 값 추출
+                                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                                        
+                                            rescue => e
+                                            puts "Error: #{e.message}"
+                                            content = "오류가 발생했습니다."
+                                            end
+                                    else
+                                    end 
+
+                                    reply_button = last_matched_item.find_element(:css, 'a.comment_info_button')
+                                    reply_button.click
+                                    sleep(1.5)
+
+                                    textarea = @driver.find_element(:css, 'textarea.comment_inbox_text')
+                                    textarea.send_keys(content)
+                                    sleep(1)
+
+                                    if option['이모티콘자동삽입'] == 'true'
+                                    puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                                    reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                    reply_comments.each_with_index do |item, index|
+                                        begin
+                                        
+                                        sticker_button = item.find_element(:css, 'a.button_sticker')
+                                        sticker_button.click
+                                        sleep(1)
+                                        rescue
+                                        end
+                                    end
+                                    begin
+                                        sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                                        random_li = sticker_list_elements.sample
+                                        random_button = random_li.find_element(:tag_name, 'button')
+                                        random_button.click
+                                        sleep(1)
+                                        inner_buttons = random_li.find_elements(:tag_name, 'button')
+                                        random_button_in_li = inner_buttons.sample
+                                        sleep(1)
+                                        random_button_in_li.click
+                                        sleep(1)
+                                    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+                                    rescue => e
+                                        puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                                    end
+                                    else
+                                    puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                                    end
 
-            if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
-                    content = ''
-            else
-                if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
-                    content = @data['내용설정']['내용'].sample[2]
-                else
-                    content = @data['내용설정']['내용'][@content_soon][2]
-                    @content_soon += 1
-                    @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
-                end
-            end
-        else 
-        end 
-              
-        # 디엠 자동 변경이 체크된 경우 content를 변환
-        if @data['포스트설정']['내용자동변경'].checked?
-            change_memory = {}
-            @data['포스트설정']['내용자동변경값'].each do |key, v|
-            change_memory[key] = v.sample
-            end
-            @data['포스트설정']['내용자동변경값'].each do |key, _|
-                if content.include?(key)
-                content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
-                else
-                end
-            end
-        end
+                                    if option['이미지자동삽입'] == 'true'
+                                    puts "이미지 자동 삽입 옵션 진행!!".cyan
+                                    @image = image
+                                    image_path = image
+                                    reply_comments = @driver.find_elements(:css, 'li.CommentItem.CommentItem--reply')
+                                    reply_comments.each_with_index do |item, index|
+                                        begin
+                                        
+                                        attach_button = item.find_element(:xpath, './/*[@class="button_file"]')
+                                        attach_button.click
+                                        sleep(1)
+                                        rescue
+                                        end
+                                    end
+                                    key_stroke('escape')
+                                    file_input = @driver.find_element(:xpath, '//*[@title="사진첨부"]')
+                                    file_input.send_keys(image_path)
+                                    sleep(2)
+                                    end
 
-        if option['좋아요'] == 'true'
-            puts "좋아요 클릭 옵션 진행!!".cyan
-            wait = Selenium::WebDriver::Wait.new(:timeout => 10)
-            wait.until { @driver.find_element(:xpath, '//*[@class="u_ico _icon"]') }
+                                    register_btn = @driver.find_element(:css, 'a.button.btn_register')
+                                    register_btn.click
+                                    sleep(2)
 
-            # 댓글 입력
-            element = @driver.find_element(:xpath, '//*[@class="u_ico _icon"]')
-            @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)#크롤 이동
-            sleep(1)
+                                    matched = true
+                                rescue => e
+                                    puts "대댓글 등록 중 오류 발생: #{e.message}"
+                                end
+                            end
+                            
+                            puts "닉네임 '#{target}'을 포함한 댓글을 찾지 못했습니다." unless matched
 
-            # 좋아요 버튼을 찾기
-            like_button = @driver.find_element(:xpath, '//div[@class="ReactionLikeIt u_likeit_list_module _cafeReactionModule"]//a[@role="button"]')
+                        end
+                    end
 
-            # aria-pressed 속성 값 확인
-            aria_pressed = like_button.attribute('aria-pressed')
+                end
 
-            if aria_pressed == 'true'
-            # 이미 좋아요를 누른 상태일 경우
-            
-            else
-            # 좋아요를 아직 누르지 않은 상태일 경우 클릭
-            @driver.find_element(:xpath, '//*[@class="u_ico _icon"]').click
-            sleep(2)
-            end
-        else
-        end    
+                elsif option['re_coment'] == 'false' # 대 댓글 아닐때 
+                    if @data['포스트설정']['순서사용2'].checked?
+                        @content_soon ||= 0  # 초기 한 번만 0으로 세팅
 
-        
-                    
+                        if @data['내용설정']['내용'].nil? || @data['내용설정']['내용'].empty?
+                            content = ''
+                        else
+                            if @data.dig('내용설정', '랜덤사용')&.respond_to?(:checked?) && @data['내용설정']['랜덤사용'].checked?
+                                content = @data['내용설정']['내용'].sample[2]
+                            else
+                                content = @data['내용설정']['내용'][@content_soon][2]
+                                @content_soon += 1
+                                @content_soon = 0 if @content_soon >= @data['내용설정']['내용'].length
+                            end
+                        end
+                    else 
+                    end 
+                            
+                    # 디엠 자동 변경이 체크된 경우 content를 변환
+                    if @data['포스트설정']['내용자동변경'].checked?
+                        change_memory = {}
+                        @data['포스트설정']['내용자동변경값'].each do |key, v|
+                        change_memory[key] = v.sample
+                        end
+                        @data['포스트설정']['내용자동변경값'].each do |key, _|
+                            if content.include?(key)
+                            content = content.gsub(key, change_memory[key]) # gsub을 사용하여 내용 치환
+                            else
+                            end
+                        end
+                    end    
 
-        begin
-            wait = Selenium::WebDriver::Wait.new(:timeout => 10)
-            wait.until { @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]') }
+                    if option['ChatGPT사용'] == 'true'
+                            pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
+                            sleep(1)
+                        
+                            puts "ChatGPT로 댓글을 만드는 중입니다."
+                            @api_key = api_key
+                            url = 'https://api.openai.com/v1/chat/completions'
+                            headers = {
+                            'Content-Type' => 'application/json',
+                            'Authorization' => 'Bearer ' + @api_key
+                            }
+                            data = {
+                            'model' => 'gpt-3.5-turbo',
+                            'messages' => [
+                                { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
+                                { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
+                            ]
+                            }
+                        
+                            begin
+                            req = HTTP.headers(headers).post(url, json: data)
+                            puts "HTTP Status: #{req.status}" # 상태 코드 확인
+                            response = JSON.parse(req.body.to_s)
+                            puts "API Response: #{response}" # 전체 응답 출력
+                        
+                            if req.status == 429
+                                return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
+                            end
+                        
+                            # 응답 데이터에서 안전하게 값 추출
+                            raw_content = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
+                            content = raw_content.gsub(/\. /, ".\n") # 줄바꿈 추가
+                        
+                            rescue => e
+                            puts "Error: #{e.message}"
+                            content = "오류가 발생했습니다."
+                            end
+                    else
+                    end 
 
-            # 댓글 입력
-            element = @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]')
-            @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)#크롤 이동
-            sleep(1)
-            if option['ChatGPT사용'] == 'true'
-                pcol1 = @driver.find_element(:css, 'div.title_area > h3.title_text').text
-                sleep(1)
-              
-                puts "ChatGPT로 댓글을 만드는 중입니다."
-                @api_key = api_key
-                url = 'https://api.openai.com/v1/chat/completions'
-                headers = {
-                  'Content-Type' => 'application/json',
-                  'Authorization' => 'Bearer ' + @api_key
-                }
-                data = {
-                  'model' => 'gpt-3.5-turbo',
-                  'messages' => [
-                    { "role" => "system", "content" => "해당 제목에 알맞은 댓글을 짧게 한 개만 만들어줘" },
-                    { "role" => "user", "content" => pcol1 } # pcol1 직접 사용
-                  ]
-                }
-              
-                begin
-                  req = HTTP.headers(headers).post(url, json: data)
-                  puts "HTTP Status: #{req.status}" # 상태 코드 확인
-                  response = JSON.parse(req.body.to_s)
-                  puts "API Response: #{response}" # 전체 응답 출력
-              
-                  if req.status == 429
-                    return "API 요청 제한을 초과했습니다. 플랜 및 할당량을 확인하세요."
-                  end
-              
-                  # 응답 데이터에서 안전하게 값 추출
-                  raw_answer = response.dig('choices', 0, 'message', 'content') || "댓글 생성을 실패했습니다." # 응답이 없을 경우 기본 메시지 설정
-                  answer = raw_answer.gsub(/\. /, ".\n") # 줄바꿈 추가
-              
-                rescue => e
-                  puts "Error: #{e.message}"
-                  answer = "오류가 발생했습니다."
-                end
-              
-                # 댓글 입력
-                @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]').send_keys(answer)
-                sleep(1)
-            else
-                begin
-                    puts (content)
-                    @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]').send_keys(content)
+                    wait = Selenium::WebDriver::Wait.new(timeout: 10)
+                    wait.until { @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]') }
+
+                    element = @driver.find_element(:xpath, '//*[@placeholder="댓글을 남겨보세요"]')
+                    @driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'center'})", element)
                     sleep(1)
-                rescue
-                end
-            end  
-            
-            # 이모티콘 자동 삽입
-            if option['이모티콘자동삽입'] == 'true'
-                puts "이모티콘 자동 삽입 옵션 진행!!".cyan
-            
-                # '이모티콘' 버튼 클릭
-                @driver.find_element(:xpath, '//*[@class="button_sticker"]').click
-                sleep(1)
-            
-                begin
-                # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
-                sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
-            
-                # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
-                random_li = sticker_list_elements.sample
-                random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
-                random_button.click
+
+                    element.send_keys(content)
+                    sleep(1)
+
+                    # 이모티콘 자동 삽입
+                    if option['이모티콘자동삽입'] == 'true'
+                        puts "이모티콘 자동 삽입 옵션 진행!!".cyan
+                        
+                        # '이모티콘' 버튼 클릭
+                        @driver.find_element(:xpath, '//*[@class="button_sticker"]').click
+                        sleep(1)
+                        
+                        begin
+                        # 'se2_line_sticker_set' 클래스를 가진 <ul> 요소 안의 모든 <li> 요소 찾기
+                        sticker_list_elements = wait.until { @driver.find_elements(:css, '.se2_line_sticker_set li') }
+                        
+                        # 16개 <li> 요소 중 랜덤으로 하나 선택하여 클릭
+                        random_li = sticker_list_elements.sample
+                        random_button = random_li.find_element(:tag_name, 'button')  # <button> 태그 찾기
+                        random_button.click
+                        
+                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+                            
+                        # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
+                        inner_buttons = random_li.find_elements(:tag_name, 'button')
+                        
+                        # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
+                        random_button_in_li = inner_buttons.sample
+                        sleep(1)
+                        random_button_in_li.click
+                        
+                        sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
+                            
+                        rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+                        #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
+                        # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
+                        # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
+                            
+                        rescue => e
+                        puts "기타 오류로 인해 이모티콘 삽입 안됨"
+                        # 기타 오류 처리
+                        # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
+                        end
+                    else
+                        puts "이모티콘 자동 삽입 옵션이 비활성화됨."
+                    end
             
-                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
-                
-                # 첫 번째 클릭한 <li> 내에서 버튼을 찾기
-                inner_buttons = random_li.find_elements(:tag_name, 'button')
+                    # 이미지 자동 삽입
+                    if option['이미지자동삽입'] == 'true'
+                        puts "이미지 자동 상입 옵션 진행!!".cyan
             
-                # 20개 <button> 요소 중 랜덤으로 하나 선택하여 클릭
-                random_button_in_li = inner_buttons.sample
-                sleep(1)
-                random_button_in_li.click
+                        # 아이프레임 요소가 나타날 때까지 기다립니다.
+                        @image = image
+                        image_path = image  
+                    
+                        @driver.find_element(:xpath, '//*[@for="attach2"]').click
+                        sleep(1)
+                        key_stroke('escape')  
+                        # 파일 경로 자동 입력
+                        file_input = @driver.find_element(:xpath, '//*[@class="button_file"]')
             
-                sleep(1)  # 클릭 후 잠시 대기 (로딩 시간 고려)
-                
-                rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
-                #puts "Stale element reference 오류 발생, 계속 진행: #{e.message}".yellow
-                # 오류 발생 시에도 계속 진행하려면 작업을 계속하도록 처리
-                # 예를 들어, continue, or next 등으로 다음 단계로 넘어갈 수 있습니다.
-                
-                rescue => e
-                puts "기타 오류로 인해 이모티콘 삽입 안됨"
-                # 기타 오류 처리
-                # 여기에 추가적인 예외 처리 로직을 넣을 수 있습니다.
-                end
-            else
-                puts "이모티콘 자동 삽입 옵션이 비활성화됨."
-            end
-
-            # 이미지 자동 삽입
-            if option['이미지자동삽입'] == 'true'
-                puts "이미지 자동 상입 옵션 진행!!".cyan
+                        # send_keys로 파일 경로를 입력하여 이미지 업로드
+                        file_input.send_keys(image_path)
+                        sleep(2)    
+                    
+                    else
+                    end
 
-                # 아이프레임 요소가 나타날 때까지 기다립니다.
-                @image = image
-                image_path = image  
-          
-                @driver.find_element(:xpath, '//*[@for="attach2"]').click
-                sleep(1)
-                key_stroke('escape')  
-                # 파일 경로 자동 입력
-                file_input = @driver.find_element(:xpath, '//*[@id="attach2"]')
+                    
+                    wait.until { @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]') }
+                    @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]').click
+                    sleep(2)
+                    posting_url = @driver.current_url
+                    puts "#{posting_url} [댓글 진행 완료 !!]".cyan
+                end
 
-                # send_keys로 파일 경로를 입력하여 이미지 업로드
-                file_input.send_keys(image_path)
-                sleep(2)    
            
-            else
-            end
 
-        
-        
-            wait.until { @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]') }
-            @driver.find_element(:xpath, '//*[@class="button btn_register is_active"]').click
-            puts "#{board_url} [댓글 작성 완료 !!]".cyan
-            sleep(2)
                 begin
                     @driver.switch_to.alert
                     sleep(1)
@@ -1334,26 +2970,28 @@ class Naver
                     ff.close()
                     puts '-[√] 로그 파일 생성 완료.......'.yellow   
                     end 
-                end 
-            end
-            @driver.switch_to.default_content()                                              # 아이프레임 해제  
-            def sleep_with_progress(sleep_delay)
-                print "[설정 딜레이 진행 중] "
-                steps = (sleep_delay.to_f / 0.5).to_i
-                steps.times do
-                    print "."
-                    STDOUT.flush
-                    sleep(1)
+                end  
+                       
+              
+                @driver.switch_to.default_content()                                              # 아이프레임 해제
+                def sleep_with_progress(sleep_delay)
+                    print "[설정 딜레이 진행 중] "
+                    steps = (sleep_delay.to_f / 0.5).to_i
+                    steps.times do
+                        print "."
+                        STDOUT.flush
+                        sleep(1)
+                    end
+                    puts "\n"
                 end
-                puts "\n"
-            end
-            sleep_with_progress(sleep_delay)
-          
 
-        rescue => e
+                sleep_with_progress(sleep_delay)
+                
+
+            rescue => e
                 puts "Error: #{e.message}"
-        end  
-        end
+            end  
+        end     
         else
         end
 
@@ -1500,7 +3138,7 @@ end
             # 상태 표시 퍼샌테이지 아래 [7]넘버는 게이지바에 맞게 넘버를 넣어줘야 작동됨
             while true
                 for n in 0..@data['table'].length-1
-                    @data['table'][n][7] = 0
+                    @data['table'][n][8] = 0
                 end
     
                 while true
@@ -1513,7 +3151,18 @@ end
                             next
                         end
     
-                   
+                        if table[4] == true
+                            option['re_coment'] = 'true'
+                            if @data['포스트설정']['전체대댓글'].checked?
+
+                            elsif @data['포스트설정']['지정대댓글'].checked?
+                                nik_or_number = @data['포스트설정']['nik_or_number'].text.to_s.force_encoding('utf-8')
+                                puts nik_or_number
+                            else 
+                            end    
+                        else
+                            option['re_coment'] = 'false'
+                        end
     
                      
                         option['proxy'] = ''
@@ -1525,7 +3174,7 @@ end
                             end
                         end
 
-                        if table[6].to_i > table[7].to_i #시작 부분 설정을 맞게해줘야 실행이 됨
+                        if table[7].to_i > table[8].to_i #시작 부분 설정을 맞게해줘야 실행이 됨
                         #if table[6].to_i #시작 부분 설정을 맞게해줘야 실행이 됨
 
                         if @data['포스트설정']['테더링'].checked?
@@ -1860,15 +3509,15 @@ end
                             # p option
     
                             # 댓글 설정 수 카운트
-                            counts_number = @data['table'][index][5].to_i
+                            counts_number = @data['table'][index][6].to_i
                             api_key = @data['포스트설정']['api_key'].text.to_s.force_encoding('utf-8')
-                            sleep_delay = @data['table'][index][4].to_i
+                            sleep_delay = @data['table'][index][5].to_i
                             naver.update(content,board_url,nickname,image,option,counts_number,keyword,api_key,sleep_delay)
                         
                             
     
                             #완료했으니 수량 카운터
-                            @data['table'][index][7] =  @data['table'][index][7].to_i + 1
+                            @data['table'][index][8] =  @data['table'][index][8].to_i + 1
                             @data['table'][index][-1] =  100
                             @data['table'] << []
                             @data['table'].pop
@@ -2243,8 +3892,8 @@ end
                                     button('　　　 댓글 등록 ID 추가　　　 '){
                             
                                         on_clicked {
-                                            @data['table'] << [false, @data['admin_list1'].text,@data['admin_list2'].text,@data['proxy'].text, 1, 2, 1,0,0]
-                                            @data['table'] << [false, @data['admin_list1'].text,@data['admin_list2'].text,@data['proxy'].text, 1, 2, 1,0,0]
+                                            @data['table'] << [false, @data['admin_list1'].text,@data['admin_list2'].text,@data['proxy'].text,false, 1, 2, 1,0,0]
+                                            @data['table'] << [false, @data['admin_list1'].text,@data['admin_list2'].text,@data['proxy'].text,false, 1, 2, 1,0,0]
                                             @data['table'].pop
                                         }
                                     }
@@ -2257,8 +3906,8 @@ end
                                                 file_data.split("\n").each do |i|
                                                     i3 = i.to_s.force_encoding('utf-8').to_s
                                                     i2 = i3.split(',')
-                                                    @data['table'] << [false, i2[0].to_s, i2[1].to_s,i2[2].to_s, 1,2,1,0,0]
-                                                    @data['table'] << [false, i2[0].to_s, i2[1].to_s, 1,2,1,0,0]
+                                                    @data['table'] << [false, i2[0].to_s, i2[1].to_s,i2[2].to_s,['1', 'true'].include?(i2[3].to_s.strip.downcase), 1,2,1,0,0]
+                                                    @data['table'] << [false, i2[0].to_s, i2[1].to_s, false, 1,2,1,0,0]
                                                     @data['table'].pop
                                                 end
                                             end
@@ -2284,6 +3933,10 @@ end
                                     text_column('프록시'){
                                         editable true
                                     } 
+
+                                    checkbox_column('대댓글작업') {
+                                        editable true
+                                    }
                                
                                    text_column('딜레이'){
                                         editable true
@@ -2378,9 +4031,9 @@ end
                                                 table_counter_again = @data['table_counter_again'].text.to_i
                                                 # @data['table']의 각 항목을 업데이트
                                                 @data['table'].map! do |row|
-                                                    row[4] = table_delay_input
-                                                    row[5] = table_counter_input
-                                                    row[6] = table_counter_again
+                                                    row[5] = table_delay_input
+                                                    row[6] = table_counter_input
+                                                    row[7] = table_counter_again
                                                     row  # 수정된 row를 반환
                                                 end
                                             }
@@ -3172,6 +4825,33 @@ end
                         end
                         }
                     }
+                    @data['포스트설정']['전체대댓글'] = checkbox('대 댓글 전체 타겟(옵션1)　'){
+                        top 1
+                        left 3
+                        on_toggled{
+                        if @data['포스트설정']['전체대댓글'].checked?
+                            @data['포스트설정']['지정대댓글'].checked = false
+                        end
+                        }
+                    }
+                    @data['포스트설정']['지정대댓글'] = checkbox('대 댓글 지정 타겟(옵션2)'){
+                        top 1
+                        left 4
+                        on_toggled{
+                        if @data['포스트설정']['지정대댓글'].checked?
+                            @data['포스트설정']['전체대댓글'].checked = false
+                        end
+                        }
+                    }
+                   @data['포스트설정']['nik_or_number'] = entry(){
+                        top 1
+                        left 5
+                        text '예)마루 or 예)1(댓글넘버)'
+                    }
+                    label('콤마로 추가 가능 예)마루,강쥐 or 예)1,3'){
+                        top 1
+                        left 6
+                    }
                    
                     }
                     }