fuck this shit

import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import java.util.Random;

public class Minesweeper extends JFrame implements Runnable
{
  final int rows = 9;
  final int columns = 9;
  final JButton [][] mineArray;
  final int [][] placeArray;

  public Minesweeper()
  {
    super("Minesweeper");
    Container cp = getContentPane();
    JPanel minePanel = new JPanel();
    mineArray = null;
    placeArray = null;
    minePanel.setLayout(new GridLayout(9,9));
    cp.add(minePanel);
    for(int x = 0; x < rows; x++)
    {
      for(int y = 0; y < columns; y++)
      {
        MineButton button = new MineButton(x, y, false);
        mineArray[x][y] = button;
        minePanel.add(button);
      }
    }
   // System.out.println(mineArray[1][1]);
  }

  public static void main(String[] args)
  {
    Minesweeper ms = new Minesweeper();
    javax.swing.SwingUtilities.invokeLater(ms);
  }

  // makes menu bar - a file option that opens to a quit option
  private void makeMenu()
  {
    JMenu fileMenu = new JMenu("File");
    JMenuItem quitItem = new JMenuItem("Quit");
    quitItem.addActionListener(e -> System.exit(0));
    fileMenu.add(quitItem);
    JMenuItem resetItem = new JMenuItem("Reset");
    fileMenu.add(resetItem);
    // RESET here

    JMenuBar menuBar = new JMenuBar();
    menuBar.add(fileMenu);
    setJMenuBar(menuBar);
  }


  public void end()
  {
    // change all buttons to fire engine red
    System.out.println("GAME OVER");
  }

  public class MineButton extends JButton
  {
    private int x;
    private int y;
    private boolean isMine;
    private boolean isFlagged;
    private int numMines;

    public MineButton(int _x, int _y, boolean _isMine)
    {
      isMine = _isMine;
      isFlagged = false;
    }

    public void setFlag()
    {
      isFlagged = !(isFlagged);
    }

    public boolean hasMine()
    {
      return isMine;
    }

    public boolean getFlag()
    {
      return isFlagged;
    }

    public void setAdjacentMineCount()
    {
      int count = 0;
     // if(x > 0 && (mineArray[x-1][y]).hasMine()) { count++; }
     // if(x < 8 && (mineArray[x+1][y]).hasMine()) { count++; }
     // if(y > 0 && (mineArray[x][y - 1]).hasMine()) { count++; }
     // if(y < 8 && (mineArray[x][y + 1]).hasMine()) { count++; }
     // diagonals
      System.out.println(mineArray[x-1][y]);
      setText(count > 0 ? "" + count : "");
      numMines = count;
    }

    public void reveal()
    {
      if(isMine)
      {
        //End the game idk
      }
      setLabel(Integer.toString(numMines));
      System.out.println(numMines);
    }


  }

  public void run()
  {
    setSize(500,500);
    setTitle("Minesweeper");
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    makeMenu();

    setVisible(true);
  }

  class ClickListener implements ActionListener
  {
    //   MineButton click = new MineButton("5", 0);
    public void actionPerformed(ActionEvent e)
    {
      //if(isRightMouseButton(e))
      if(4 == 5)
      {
        //getFlag();
        // this is the flag function - we want to implement something similar to grenredyellowstopthing
      }

      else
      {
        //if(a.getFlag())
        {
          return;
        }
        //else
        //{
        //a.reveal();
        //}
      }
    }
  }

public void generateMines()
  //Maybe we should make sure that the first mine clicked doesn't become a bomb.
  {
    Random r = new Random();
    for(int a = 0; a < 10; a = a)
    {
      MineButton change = mineArray[r.nextInt(10)] [r.nextInt(10)];
      System.out.println(change);
      if(change.hasMine())
      {
        return;
      }
      else
      {
        change.setMine();
        a++;
      }
    }

    return;
  }


  /*
   * Game Structure:
   * begin with all unlabeled buttons
   * when the first button is clicked, make sure that button isn't a mine. Maybe make sure that several buttons reveal themselves?
   * randomly assign the positions of the (10?) bombs
   * fill the number labels of each so that they represent how many mines each is touching
   * when the user clicks on a non-revealed block, have the game end if it's a mine. Otherwise, have it reveal the block that is
   * clicked and any surrounding blocks with a value of 0. We need to set off a chain reaction of some kind here?
   * When the user right clicks on a non-revealed block, mark the block with a flag.
   * Turn off the (left)clickability for any flagged block. Right clicking again unflags.
   * Have a counter for the number of flags used in the game and the number of flags left.
   * The game ends when all non-mine blocks are revealed or a mine is clicked.
   * If the user loses, display where all the mines were that hadn't been clicked. Have the clicked mine turn red.
   */
}