import os
import sys
import win32com.client
import glob
from datetime import datetime
import shutil
import logging
import time

# Add these imports for process termination
import win32process
import win32gui
import win32con
import win32api

def setup_logging():
    logging.basicConfig(
        filename=f'ItemProcess_{datetime.now().strftime("%Y%m%d")}.log',
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s'
    )

def find_item_workbook():
    # Look for Item_*.xls* in the current directory
    item_files = glob.glob('Item_*.xls*')
    if not item_files:
        raise FileNotFoundError("No Item_*.xls* file found in the current directory")
    if len(item_files) > 1:
        logging.warning("Multiple Item_* files found. Using the most recent one.")
        return max(item_files, key=os.path.getctime)
    return item_files[0]

def ensure_archive_folder():
    archive_folder = "ArchivedExports"
    if not os.path.exists(archive_folder):
        os.makedirs(archive_folder)
        logging.info(f"Created archive folder: {archive_folder}")
    return archive_folder

def get_excel_application():
    try:
        # Try to connect to an existing Excel instance
        excel = win32com.client.GetObject(Class="Excel.Application")
        logging.info("Connected to existing Excel instance")
    except:
        # If no Excel instance exists, create a new one
        excel = win32com.client.Dispatch("Excel.Application")
        logging.info("Created new Excel instance")
    
    excel.Visible = False
    excel.DisplayAlerts = False
    return excel

def is_ignorable_error(e):
    # Check if the error matches the specific error code we want to ignore
    error_code = -2147352567
    try:
        if isinstance(e, Exception) and hasattr(e, 'args') and len(e.args) > 0:
            if isinstance(e.args[0], int) and e.args[0] == error_code:
                return True
    except:
        pass
    return False

def run_macro(excel, workbook):
    try:
        macro_path = f"'{workbook.Name}'!ProcessInventoryData"
        logging.info(f"Attempting to run macro: {macro_path}")
        excel.Run(macro_path)
        logging.info("Macro executed successfully")
        return True
    except Exception as e:
        if is_ignorable_error(e):
            logging.warning(f"Encountered ignorable error during macro execution: {str(e)}")
            logging.info("Continuing process despite error...")
            return True
        else:
            logging.error(f"Error running macro: {str(e)}")
            raise

def move_file_with_retry(source, destination, max_retries=3, delay=2):
    """
    Attempt to move a file with retries in case of file locks
    """
    for attempt in range(max_retries):
        try:
            if os.path.exists(source):
                logging.info(f"Attempting to move file: {source} to {destination}")
                shutil.move(source, destination)
                logging.info(f"Successfully moved file to: {destination}")
                return True
            else:
                logging.error(f"Source file not found: {source}")
                return False
        except Exception as e:
            logging.warning(f"Move attempt {attempt + 1} failed: {str(e)}")
            if attempt < max_retries - 1:
                time.sleep(delay)
            else:
                logging.error(f"Failed to move file after {max_retries} attempts")
                raise

def process_workbooks():
    excel = None
    item_workbook_path = None
    
    try:
        # Initialize Excel
        excel = get_excel_application()
        
        # Find the input workbook and store its path
        item_workbook_path = os.path.abspath(find_item_workbook())
        master_workbook_path = "MasterItemProcess.xls"
        
        if not os.path.exists(master_workbook_path):
            raise FileNotFoundError("MasterItemProcess.xls not found in the current directory")
        
        logging.info(f"Processing {item_workbook_path}")
        
        # Open MasterItemProcess.xls
        master_wb = excel.Workbooks.Open(os.path.abspath(master_workbook_path))
        
        # Clear all cells in the active worksheet
        master_wb.Sheets(1).Cells.Clear()
        
        # Open and copy data from Item_* workbook
        item_wb = excel.Workbooks.Open(item_workbook_path)
        item_wb.Sheets(1).UsedRange.Copy(master_wb.Sheets(1).Range("A1"))
        item_wb.Close(SaveChanges=False)
        
        # Run the macro - continue if it returns True (success or ignorable error)
        if run_macro(excel, master_wb):
            # Close Excel properly before moving files
            if excel:
                excel.Quit()
                excel = None
                time.sleep(2)  # Give Excel time to fully close
            
            # Move Item_* file to archive
            archive_folder = ensure_archive_folder()
            archive_path = os.path.join(
                archive_folder,
                f"Archived_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.path.basename(item_workbook_path)}"
            )
            
            # Move the file with retry mechanism
            move_file_with_retry(item_workbook_path, archive_path)

            logging.info("Continuing process after move_file_with_retry finishes...")
        
    except Exception as e:
        if is_ignorable_error(e):
            logging.warning(f"Encountered ignorable error: {str(e)}")
            logging.info("Continuing process despite error...")
        else:
            logging.error(f"Error: {str(e)}")
            raise
    '''    
    finally:
        if excel:
            try:
                excel.Quit()
            except:
                pass
    '''

def force_terminate_excel():
    """Force terminate any remaining Excel processes"""
    try:
        os.system('taskkill /F /IM excel.exe')
    except:
        pass

def main():
    setup_logging()
    logging.info("Starting ItemProcess")
    exit_code = 0

    process_workbooks()
    logging.info("process_workbooks completed")

    force_terminate_excel()  # Ensure Excel is fully terminated
        
    # Force close the command prompt window
    try:
        hwnd = win32gui.GetForegroundWindow()
        win32api.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
    except:
        pass
    
    os._exit(exit_code)  # Force immediate termination
    
    '''
    try:
        process_workbooks()
        logging.info("process_workbooks completed")
    except Exception as e:
        if is_ignorable_error(e):
            logging.warning(f"Process completed with ignorable error: {str(e)}")
        else:
            logging.error(f"Process failed: {str(e)}")
            print(f"Error: {str(e)}")
            exit_code = 1
    finally:
        logging.info("Process completed")

        #sys.exit(exit_code)
        sys.exit(0)
    '''

if __name__ == "__main__":
    main()